@mcp-graph-workflow/agent-graph-flow 0.1.4 → 0.3.0

package/dist/cli/index.js

@@ -11,7 +11,7 @@ import { randomUUID, randomBytes, createHash } from 'crypto';
 import os, { homedir } from 'os';
 import { stat, readFile, access, constants } from 'fs/promises';
 import { execFile, execSync, spawn } from 'child_process';
-import { render, useApp, Box, Text } from 'ink';
+import { render, useApp, useInput, Box, Text } from 'ink';
 import { jsx, jsxs } from 'react/jsx-runtime';
 import { createElement, useState, useCallback, useEffect } from 'react';
 import TextInput from 'ink-text-input';
@@ -2863,6 +2863,33 @@ var init_migrations = __esm({
       FROM events e
       WHERE e.kind = 'tool.completed'
         AND e.subjectRef_kind = 'mcp.tool';
+    `
+      },
+      {
+        version: 96,
+        // λ_flow (transient-hypofrontality) telemetry. Records, per context call, the
+        // flow state (Φ, λ_flow) and how much topological decay pruned vs. pinned,
+        // tagged flow_on/flow_off for A/B. Telemetry-only — never affects graph state.
+        // Pairs with flow-metrics-store.ts / flow-report.ts.
+        description: "flow_metrics \u2014 \u03BB_flow (hipofrontalidade) A/B telemetry",
+        sql: `
+      CREATE TABLE IF NOT EXISTS flow_metrics (
+        id              TEXT PRIMARY KEY,
+        project_id      TEXT NOT NULL,
+        node_id         TEXT NOT NULL,
+        mode            TEXT NOT NULL,
+        phi             REAL NOT NULL,
+        lambda          REAL NOT NULL,
+        tokens_baseline INTEGER NOT NULL,
+        tokens_actual   INTEGER NOT NULL,
+        pruned_count    INTEGER NOT NULL,
+        pinned_count    INTEGER NOT NULL,
+        created_at      INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_flow_metrics_project_created
+        ON flow_metrics(project_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_flow_metrics_mode
+        ON flow_metrics(mode, created_at DESC);
     `
       }
     ];
@@ -5408,6 +5435,13 @@ function getNodeAcTexts(doc, nodeId) {
   if (inline.length > 0) return inline;
   return _acByParent.get(nodeId) ?? [];
 }
+function getNodeAcFromStore(store2, nodeId) {
+  const node = store2.getNodeById(nodeId);
+  if (!node) return [];
+  const inline = node.acceptanceCriteria ?? [];
+  if (inline.length > 0) return inline;
+  return store2.getChildNodes(nodeId).filter((n) => n.type === "acceptance_criteria").map((n) => n.title);
+}
 function nodeHasAc(doc, nodeId) {
   return getNodeAcTexts(doc, nodeId).length > 0;
 }
@@ -6805,9 +6839,15 @@ var init_copilot_sdk_adapter = __esm({
     init_logger();
     log22 = createLogger({ layer: "core", source: "copilot-sdk-adapter.ts" });
     ModelAdapterError = class extends McpGraphError {
-      constructor(message) {
+      /** HTTP status quando a falha veio de uma resposta do provider (p/ classifyLlmError). */
+      status;
+      /** Espera sugerida (ms), derivada de `retry-after` em respostas 429. */
+      retryAfterMs;
+      constructor(message, opts = {}) {
         super(`Model adapter error: ${message}`);
         this.name = "ModelAdapterError";
+        this.status = opts.status;
+        this.retryAfterMs = opts.retryAfterMs;
       }
     };
     CopilotSdkAdapter = class {
@@ -6898,9 +6938,16 @@ var init_copilot_api_adapter = __esm({
         }
         if (!res.ok) {
           if (res.status === 401 || res.status === 403) {
-            throw new ModelAdapterError("token Copilot expirado/inv\xE1lido (401/403) \u2014 rode `agf login` novamente.");
+            throw new ModelAdapterError("token Copilot expirado/inv\xE1lido (401/403) \u2014 rode `agf login` novamente.", {
+              status: res.status
+            });
           }
-          throw new ModelAdapterError(`API do Copilot retornou ${res.status}: ${(await res.text()).slice(0, 200)}`);
+          const retryAfterRaw = res.headers?.get?.("retry-after");
+          const retryAfterMs = retryAfterRaw && Number.isFinite(Number(retryAfterRaw)) ? Math.round(Number(retryAfterRaw) * 1e3) : void 0;
+          throw new ModelAdapterError(`API do Copilot retornou ${res.status}: ${(await res.text()).slice(0, 200)}`, {
+            status: res.status,
+            retryAfterMs
+          });
         }
         const body = await res.json();
         const text = body.choices?.[0]?.message?.content;
@@ -7044,8 +7091,8 @@ var init_implementation_executor = __esm({
     };
     defaultRunner = (command, cwd) => {
       try {
-        const output15 = execSync(command, { cwd, encoding: "utf8", stdio: "pipe" });
-        return { exitCode: 0, output: output15 };
+        const output16 = execSync(command, { cwd, encoding: "utf8", stdio: "pipe" });
+        return { exitCode: 0, output: output16 };
       } catch (err) {
         const e = err;
         return {
@@ -7125,11 +7172,89 @@ var init_plan_parser = __esm({
   }
 });
 
+// src/core/model-hub/llm-error.ts
+function readHeader(headers, name) {
+  if (!headers || typeof headers !== "object") return null;
+  const getter = headers.get;
+  if (typeof getter === "function") {
+    const v = getter.call(headers, name);
+    return typeof v === "string" ? v : null;
+  }
+  const lower = name.toLowerCase();
+  for (const [k, v] of Object.entries(headers)) {
+    if (k.toLowerCase() === lower && typeof v === "string") return v;
+  }
+  return null;
+}
+function extractStatus(err) {
+  const candidates = [err.status, err.statusCode, err.response?.status];
+  for (const c of candidates) {
+    const n = typeof c === "number" ? c : typeof c === "string" ? Number(c) : NaN;
+    if (Number.isFinite(n) && n >= 100 && n < 600) return n;
+  }
+  if (typeof err.message === "string") {
+    const m = err.message.match(/\b(4\d\d|5\d\d)\b/);
+    if (m) return Number(m[1]);
+  }
+  return void 0;
+}
+function resolveRetryAfterMs(err) {
+  if (typeof err.retryAfterMs === "number" && err.retryAfterMs >= 0) return err.retryAfterMs;
+  const headers = err.headers ?? err.response?.headers;
+  const raw = readHeader(headers, "retry-after");
+  if (raw !== null) {
+    const seconds = Number(raw);
+    if (Number.isFinite(seconds) && seconds >= 0) return Math.round(seconds * 1e3);
+  }
+  return DEFAULT_RATE_LIMIT_MS;
+}
+function classifyLlmError(err) {
+  const e = err && typeof err === "object" ? err : {};
+  const message = typeof e.message === "string" ? e.message : "";
+  const status = extractStatus(e);
+  if (status === 429) {
+    return { kind: "rate_limit", retryable: true, retryAfterMs: resolveRetryAfterMs(e) };
+  }
+  if (status === 401 || status === 403) {
+    return { kind: "auth", retryable: false };
+  }
+  if (status !== void 0 && status >= 400 && status < 500 && CONTENT_POLICY_RE.test(message)) {
+    return { kind: "content_policy", retryable: false };
+  }
+  if (status !== void 0 && status >= 400 && status < 500) {
+    return { kind: "invalid_request", retryable: false };
+  }
+  if (status !== void 0 && RETRYABLE_5XX.has(status)) {
+    return { kind: "server", retryable: true };
+  }
+  const code = typeof e.code === "string" ? e.code : "";
+  if (NETWORK_CODE.has(code) || status === void 0 && NETWORK_MSG_RE.test(message)) {
+    return { kind: "network", retryable: true };
+  }
+  return { kind: "unknown", retryable: false };
+}
+var DEFAULT_RATE_LIMIT_MS, CONTENT_POLICY_RE, NETWORK_CODE, NETWORK_MSG_RE, RETRYABLE_5XX;
+var init_llm_error = __esm({
+  "src/core/model-hub/llm-error.ts"() {
+    init_esm_shims();
+    DEFAULT_RATE_LIMIT_MS = 1e3;
+    CONTENT_POLICY_RE = /content[_\s-]?filter|content[_\s-]?policy|policy violation|moderat/i;
+    NETWORK_CODE = /* @__PURE__ */ new Set(["ECONNRESET", "ETIMEDOUT", "ECONNREFUSED", "EAI_AGAIN", "EPIPE", "ENOTFOUND"]);
+    NETWORK_MSG_RE = /fetch failed|network|socket hang up|timed? out|timeout|aborted|abort/i;
+    RETRYABLE_5XX = /* @__PURE__ */ new Set([500, 502, 503, 504, 529]);
+  }
+});
+
 // src/core/autonomy/implement-attempt.ts
+function defaultSleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
 function buildInitialPrompt(node, opts = {}) {
   const repoMapBlock = opts.repoMap && opts.repoMap.length > 0 ? [`Contexto do reposit\xF3rio (refer\xEAncia, n\xE3o reescreva o que j\xE1 existe):`, opts.repoMap, ""] : [];
+  const flowBlock = opts.flowContext && opts.flowContext.length > 0 ? [opts.flowContext, ""] : [];
   return [
     ...repoMapBlock,
+    ...flowBlock,
     `Implemente a task "${node.title}" (id: ${node.id}) seguindo TDD.`,
     "Responda APENAS com um bloco ```json. H\xE1 DOIS mecanismos:",
     '- "edits" (PREFIRA \u2014 economia de token): [{ "path", "oldString", "newString", "replaceAll"? }].',
@@ -7155,16 +7280,40 @@ function buildRetryPrompt(node, failure, maxFeedbackChars) {
 async function attemptImplementation(deps, options) {
   const maxAttempts = Math.max(1, options.maxAttempts);
   const maxFeedbackChars = options.maxFeedbackChars ?? DEFAULT_MAX_FEEDBACK_CHARS;
+  const sleep2 = deps.sleep ?? defaultSleep;
   let lastResult;
   let lastError;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    const prompt = attempt === 1 || !lastResult ? buildInitialPrompt(options.node, { repoMap: options.repoMap }) : buildRetryPrompt(options.node, lastResult, maxFeedbackChars);
+    const prompt = attempt === 1 || !lastResult ? buildInitialPrompt(options.node, { repoMap: options.repoMap, flowContext: options.flowContext }) : buildRetryPrompt(options.node, lastResult, maxFeedbackChars);
+    let text;
+    try {
+      text = await deps.generate(prompt);
+    } catch (err) {
+      lastError = getErrorMessage(err);
+      const cls = classifyLlmError(err);
+      if (!cls.retryable) {
+        log25.warn("Erro permanente do provider \u2014 escalando sem re-tentar", {
+          attempt,
+          node: options.node.id,
+          kind: cls.kind,
+          error: lastError
+        });
+        return { success: false, attempts: attempt, lastResult, error: lastError };
+      }
+      if (cls.retryAfterMs && cls.retryAfterMs > 0) await sleep2(cls.retryAfterMs);
+      log25.warn("Erro transit\xF3rio do provider \u2014 re-tentando", {
+        attempt,
+        node: options.node.id,
+        kind: cls.kind,
+        retryAfterMs: cls.retryAfterMs
+      });
+      continue;
+    }
     let plan;
     try {
-      const text = await deps.generate(prompt);
       plan = parseImplementationPlan(text);
     } catch (err) {
-      lastError = err instanceof Error ? err.message : String(err);
+      lastError = getErrorMessage(err);
       log25.warn("Tentativa falhou no parse", { attempt, node: options.node.id, error: lastError });
       continue;
     }
@@ -7183,8 +7332,10 @@ var init_implement_attempt = __esm({
   "src/core/autonomy/implement-attempt.ts"() {
     init_esm_shims();
     init_logger();
+    init_errors();
     init_truncate();
     init_plan_parser();
+    init_llm_error();
     log25 = createLogger({ layer: "core", source: "implement-attempt.ts" });
     DEFAULT_MAX_FEEDBACK_CHARS = 1200;
   }
@@ -7573,6 +7724,854 @@ var init_repo_map = __esm({
     FOCUS_BOOST = 3;
   }
 });
+var LspConfigOverrideSchema, LspDiagnosticSchema, LspDocumentSymbolSchema, LspTextEditSchema, LspWorkspaceEditSchema;
+var init_lsp_types = __esm({
+  "src/core/lsp/lsp-types.ts"() {
+    init_esm_shims();
+    z.object({
+      languageId: z.string(),
+      extensions: z.array(z.string()),
+      command: z.string(),
+      args: z.array(z.string()),
+      configFiles: z.array(z.string()),
+      probeCommand: z.string().optional(),
+      initializationOptions: z.record(z.string(), z.unknown()).optional(),
+      settings: z.record(z.string(), z.unknown()).optional()
+    });
+    LspConfigOverrideSchema = z.object({
+      languageId: z.string(),
+      command: z.string(),
+      args: z.array(z.string()).default([]),
+      extensions: z.array(z.string()).optional(),
+      initializationOptions: z.record(z.string(), z.unknown()).optional(),
+      settings: z.record(z.string(), z.unknown()).optional()
+    });
+    z.object({
+      file: z.string(),
+      startLine: z.int().min(0),
+      startCharacter: z.int().min(0),
+      endLine: z.int().min(0),
+      endCharacter: z.int().min(0)
+    });
+    z.object({
+      signature: z.string(),
+      documentation: z.string().optional(),
+      language: z.string().optional()
+    });
+    LspDiagnosticSchema = z.object({
+      file: z.string(),
+      startLine: z.int().min(0),
+      startCharacter: z.int().min(0),
+      endLine: z.int().min(0),
+      endCharacter: z.int().min(0),
+      severity: z.number().int().min(1).max(4),
+      message: z.string(),
+      code: z.string().optional(),
+      source: z.string().optional()
+    });
+    z.object({
+      name: z.string(),
+      kind: z.string(),
+      file: z.string(),
+      startLine: z.int().min(0),
+      endLine: z.int().min(0)
+    });
+    LspDocumentSymbolSchema = z.object({
+      name: z.string(),
+      kind: z.string(),
+      file: z.string(),
+      startLine: z.int().min(0),
+      endLine: z.int().min(0),
+      children: z.lazy(() => z.array(LspDocumentSymbolSchema)).optional()
+    });
+    LspTextEditSchema = z.object({
+      file: z.string(),
+      startLine: z.int().min(0),
+      startCharacter: z.int().min(0),
+      endLine: z.int().min(0),
+      endCharacter: z.int().min(0),
+      newText: z.string()
+    });
+    LspWorkspaceEditSchema = z.object({
+      changes: z.array(LspTextEditSchema)
+    });
+    z.object({
+      languageId: z.string(),
+      status: z.enum(["stopped", "starting", "ready", "error"]),
+      pid: z.number().int().optional(),
+      error: z.string().optional()
+    });
+    z.object({
+      languageId: z.string(),
+      confidence: z.number().min(0).max(1),
+      detectedVia: z.enum(["file_extension", "config_file", "shebang"]),
+      fileCount: z.int().min(0),
+      configFile: z.string().optional()
+    });
+    z.object({
+      title: z.string(),
+      kind: z.string().optional(),
+      isPreferred: z.boolean().optional(),
+      edit: LspWorkspaceEditSchema.optional(),
+      diagnostics: z.array(LspDiagnosticSchema).optional()
+    });
+    z.object({
+      applied: z.boolean(),
+      filesModified: z.array(z.string()),
+      totalEdits: z.number().int(),
+      errors: z.array(z.string()),
+      backups: z.map(z.string(), z.string()).optional()
+    });
+  }
+});
+var BROWSER_PILOT_MODELS, ContextModeSchema, ProfileFilterConfigSchema, BrowserAutomationConfigSchema, FlowConfigSchema, ConfigSchema;
+var init_config_schema = __esm({
+  "src/core/config/config-schema.ts"() {
+    init_esm_shims();
+    init_lsp_types();
+    BROWSER_PILOT_MODELS = ["claude-3.5-sonnet", "gpt-4o", "gpt-4o-mini", "o1", "o1-mini"];
+    ContextModeSchema = z.enum(["ultra-lean", "lean", "full"]);
+    ProfileFilterConfigSchema = z.enum(["core", "pro", "expert", "all"]);
+    BrowserAutomationConfigSchema = z.object({
+      enabled: z.boolean().default(false),
+      bridgeUrl: z.string().regex(/^https?:\/\//, "bridgeUrl must start with http:// or https://").default("http://127.0.0.1:9876/v1"),
+      defaultModel: z.enum(BROWSER_PILOT_MODELS).default("claude-3.5-sonnet"),
+      defaultCdpUrl: z.string().min(1).optional(),
+      allowedDomains: z.array(z.string().min(1)).default([]),
+      forbiddenCdpMethods: z.array(z.string().min(1)).default(["Browser.close"]),
+      maxStepsDefault: z.number().int().min(1).max(100).default(25),
+      tokenBudgetPerDay: z.number().int().nonnegative().optional()
+    }).default({
+      enabled: false,
+      bridgeUrl: "http://127.0.0.1:9876/v1",
+      defaultModel: "claude-3.5-sonnet",
+      allowedDomains: [],
+      forbiddenCdpMethods: ["Browser.close"],
+      maxStepsDefault: 25
+    });
+    FlowConfigSchema = z.object({
+      /** Master switch. OFF = byte-identical legacy context behaviour. */
+      enabled: z.boolean().default(false),
+      /** λ_base — minimum architectural forgetting rate. */
+      lambdaBase: z.number().min(0).default(0.15),
+      /** α — hypofrontality accelerator (weight of Φ on λ_flow). */
+      alpha: z.number().min(0).default(1.5),
+      /** BFS depth used to pull distant pinned invariants back into scope. */
+      maxDepth: z.number().int().min(0).max(6).default(3),
+      /** Peripheral neighbours below this decayed weight are pruned (unless pinned). */
+      weightThreshold: z.number().min(0).max(1).default(0.1),
+      /** EMA gain per consecutive success when computing Φ. */
+      emaGain: z.number().min(0).max(1).default(0.34),
+      /** Multiplier applied to Φ on a failure (0 = hard reset → re-hydrate memory). */
+      resetFactor: z.number().min(0).max(1).default(0),
+      /** Damping fraction of `emaGain` applied on a `partial` outcome. */
+      partialFactor: z.number().min(0).max(1).default(0.5),
+      /** rag budget is never scaled below this fraction of baseline (long-range safety). */
+      budgetFloorRatio: z.number().min(0).max(1).default(0.25),
+      /** How many recent task outcomes feed Φ. */
+      historyWindow: z.number().int().min(1).max(200).default(12),
+      /** Node types that are never diluted. */
+      pinnedTypes: z.array(z.string()).default(["constraint", "risk", "decision", "acceptance_criteria", "constitution", "requirement"]),
+      /** A/B experiment: alternate flow_on/flow_off deterministically per node to measure impact. */
+      experiment: z.object({ abEnabled: z.boolean().default(false) }).default({ abEnabled: false })
+    });
+    ConfigSchema = z.object({
+      port: z.number().int().min(1).max(65535).default(3e3),
+      dbPath: z.string().default("workflow-graph"),
+      basePath: z.string().optional(),
+      contextMode: ContextModeSchema.default("lean"),
+      profile: ProfileFilterConfigSchema.default("all"),
+      dashboard: z.object({
+        autoOpen: z.boolean().default(true)
+      }).default({ autoOpen: true }),
+      integrations: z.object({
+        codeGraphAutoIndex: z.boolean().default(true),
+        codeGraphReindexIntervalSec: z.number().int().min(0).default(0),
+        lspServers: z.array(LspConfigOverrideSchema).default([]),
+        browserAutomation: BrowserAutomationConfigSchema
+      }).prefault({}),
+      flow: FlowConfigSchema.prefault({})
+    });
+  }
+});
+
+// src/core/context/flow-config.ts
+function resolveFlowConfig(source) {
+  const raw = source.getProjectSetting(FLOW_CONFIG_SETTING_KEY);
+  if (!raw) return FlowConfigSchema.parse({});
+  try {
+    return FlowConfigSchema.parse(JSON.parse(raw));
+  } catch {
+    return FlowConfigSchema.parse({});
+  }
+}
+function flowAbArm(nodeId) {
+  let sum = 0;
+  for (let i = 0; i < nodeId.length; i += 1) sum += nodeId.charCodeAt(i);
+  return sum % 2 === 0 ? "flow_on" : "flow_off";
+}
+var FLOW_CONFIG_SETTING_KEY;
+var init_flow_config = __esm({
+  "src/core/context/flow-config.ts"() {
+    init_esm_shims();
+    init_config_schema();
+    FLOW_CONFIG_SETTING_KEY = "flow_config";
+  }
+});
+
+// src/core/context/flow-index.ts
+function computeFlowIndex(outcomesNewestFirst, tuning = {}) {
+  const { emaGain, resetFactor, partialFactor } = { ...DEFAULT_FLOW_TUNING, ...tuning };
+  let streak = 0;
+  for (const outcome of outcomesNewestFirst) {
+    if (outcome === "success") streak += 1;
+    else break;
+  }
+  let phi = 0;
+  for (let i = outcomesNewestFirst.length - 1; i >= 0; i -= 1) {
+    const outcome = outcomesNewestFirst[i];
+    if (outcome === "success") {
+      phi += emaGain * (1 - phi);
+    } else if (outcome === "failure") {
+      phi *= resetFactor;
+    } else {
+      phi *= 1 - emaGain * partialFactor;
+    }
+  }
+  phi = Math.min(1, Math.max(0, phi));
+  return { phi, streak, sampleCount: outcomesNewestFirst.length };
+}
+function computeLambdaFlow(phi, lambdaBase, alpha) {
+  return lambdaBase + alpha * phi;
+}
+function decayWeight(lambda, distance) {
+  return Math.exp(-lambda * distance);
+}
+var DEFAULT_FLOW_TUNING;
+var init_flow_index = __esm({
+  "src/core/context/flow-index.ts"() {
+    init_esm_shims();
+    DEFAULT_FLOW_TUNING = {
+      emaGain: 0.34,
+      resetFactor: 0,
+      partialFactor: 0.5
+    };
+  }
+});
+
+// src/core/context/token-estimator.ts
+function isAsciiLetter(code) {
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function isAsciiDigit(code) {
+  return code >= 48 && code <= 57;
+}
+function isWhitespace(code) {
+  return code === 32 || code === 9 || code === 10 || code === 13 || code === 12 || code === 11;
+}
+function estimateTokens2(text) {
+  if (!text) return 0;
+  let tokens = 0;
+  const len = text.length;
+  let i = 0;
+  while (i < len) {
+    const code = text.charCodeAt(i);
+    if (isWhitespace(code)) {
+      i++;
+      continue;
+    }
+    if (isAsciiLetter(code)) {
+      const start = i;
+      i++;
+      let subWords = 1;
+      while (i < len && isAsciiLetter(text.charCodeAt(i))) {
+        if (i > start && text.charCodeAt(i) >= 65 && text.charCodeAt(i) <= 90 && text.charCodeAt(i - 1) >= 97 && text.charCodeAt(i - 1) <= 122) {
+          subWords++;
+        }
+        i++;
+      }
+      const wordLen = i - start;
+      if (subWords > 1) {
+        tokens += subWords;
+      } else {
+        tokens += wordLen <= 6 ? 1 : wordLen > 20 ? Math.ceil(wordLen / 4) : Math.ceil(wordLen / 5);
+      }
+      continue;
+    }
+    if (isAsciiDigit(code)) {
+      const start = i;
+      i++;
+      while (i < len && isAsciiDigit(text.charCodeAt(i))) i++;
+      const digitsLen = i - start;
+      tokens += Math.ceil(digitsLen / 3);
+      continue;
+    }
+    tokens += 1;
+    i++;
+  }
+  return tokens;
+}
+var init_token_estimator = __esm({
+  "src/core/context/token-estimator.ts"() {
+    init_esm_shims();
+  }
+});
+
+// src/core/context/compact-context.ts
+function toTaskSummary(node) {
+  const summary = {
+    id: node.id,
+    type: node.type,
+    title: node.title,
+    status: node.status,
+    priority: node.priority
+  };
+  if (node.description) summary.description = node.description;
+  if (node.sprint) summary.sprint = node.sprint;
+  if (node.xpSize) summary.xpSize = node.xpSize;
+  if (node.tags?.length) summary.tags = node.tags;
+  return summary;
+}
+function isInferred(edge) {
+  return edge.metadata?.inferred === true;
+}
+function buildTaskContext(store2, nodeId, snapshot) {
+  const resolveNode = (id) => {
+    return store2.getNodeById(id);
+  };
+  const node = resolveNode(nodeId);
+  if (!node) {
+    log26.warn(`buildTaskContext: node ${nodeId} not found`);
+    return null;
+  }
+  let parent = null;
+  if (node.parentId) {
+    const parentNode = resolveNode(node.parentId);
+    if (parentNode) parent = toTaskSummary(parentNode);
+  }
+  let childNodes;
+  {
+    childNodes = store2.getChildNodes(nodeId);
+  }
+  const children = childNodes.map(toTaskSummary);
+  let incomingEdges;
+  let outgoingEdges;
+  {
+    incomingEdges = store2.getEdgesTo(nodeId);
+    outgoingEdges = store2.getEdgesFrom(nodeId);
+  }
+  const blockers = [];
+  const dependsOn = [];
+  const relatedIds = /* @__PURE__ */ new Set();
+  const relatedNodes = [];
+  const implementsNodes = [];
+  const derivedFromNodes = [];
+  let edgeParent = null;
+  const edgeChildren = [];
+  const edgeChildrenIds = /* @__PURE__ */ new Set();
+  for (const edge of incomingEdges) {
+    if (edge.relationType === "blocks") {
+      const blockerNode = resolveNode(edge.from);
+      if (blockerNode) {
+        blockers.push({
+          id: blockerNode.id,
+          title: blockerNode.title,
+          status: blockerNode.status,
+          relationType: edge.relationType,
+          inferred: isInferred(edge)
+        });
+      }
+    } else if (edge.relationType === "related_to") {
+      const relNode = resolveNode(edge.from);
+      if (relNode && !relatedIds.has(relNode.id)) {
+        relatedIds.add(relNode.id);
+        relatedNodes.push(toTaskSummary(relNode));
+      }
+    } else if (edge.relationType === "parent_of" && !edgeParent) {
+      const parentNode = resolveNode(edge.from);
+      if (parentNode) edgeParent = toTaskSummary(parentNode);
+    }
+  }
+  for (const edge of outgoingEdges) {
+    if (edge.relationType === "depends_on") {
+      const depNode = resolveNode(edge.to);
+      if (depNode) {
+        dependsOn.push({
+          id: depNode.id,
+          title: depNode.title,
+          status: depNode.status,
+          resolved: depNode.status === "done",
+          inferred: isInferred(edge)
+        });
+      }
+    } else if (edge.relationType === "related_to") {
+      const relNode = resolveNode(edge.to);
+      if (relNode && !relatedIds.has(relNode.id)) {
+        relatedIds.add(relNode.id);
+        relatedNodes.push(toTaskSummary(relNode));
+      }
+    } else if (edge.relationType === "implements") {
+      const implNode = resolveNode(edge.to);
+      if (implNode) implementsNodes.push(toTaskSummary(implNode));
+    } else if (edge.relationType === "derived_from") {
+      const derivedNode = resolveNode(edge.to);
+      if (derivedNode) derivedFromNodes.push(toTaskSummary(derivedNode));
+    } else if (edge.relationType === "parent_of") {
+      const childNode = resolveNode(edge.to);
+      if (childNode && !edgeChildrenIds.has(childNode.id)) {
+        edgeChildrenIds.add(childNode.id);
+        edgeChildren.push(toTaskSummary(childNode));
+      }
+    }
+  }
+  const acceptanceCriteria = getNodeAcFromStore(store2, node.id);
+  const sourceRef = node.sourceRef ? { ...node.sourceRef } : null;
+  const localNodes = [node, ...childNodes];
+  const originalChars = localNodes.reduce(
+    (sum, n) => sum + n.title.length + (n.description?.length ?? 0) + (n.acceptanceCriteria?.join("").length ?? 0),
+    0
+  ) + [...incomingEdges, ...outgoingEdges].reduce((sum, e) => sum + (e.reason?.length ?? 0), 0);
+  const summary = toTaskSummary(node);
+  const corePayload = {
+    task: summary,
+    parent,
+    children,
+    blockers,
+    dependsOn,
+    relatedNodes: relatedNodes.length > 0 ? relatedNodes : void 0,
+    implementsNodes: implementsNodes.length > 0 ? implementsNodes : void 0,
+    derivedFromNodes: derivedFromNodes.length > 0 ? derivedFromNodes : void 0,
+    edgeParent: edgeParent ?? void 0,
+    edgeChildren: edgeChildren.length > 0 ? edgeChildren : void 0,
+    acceptanceCriteria,
+    sourceRef,
+    metrics: { originalChars: 0, compactChars: 0, reductionPercent: 0, estimatedTokens: 0 }
+  };
+  const compactJson = JSON.stringify(corePayload);
+  const compactChars = compactJson.length;
+  const reductionPercent = originalChars > 0 ? Math.round((originalChars - compactChars) / originalChars * 100) : 0;
+  const metrics = {
+    originalChars,
+    compactChars,
+    reductionPercent,
+    estimatedTokens: estimateTokens2(compactJson)
+  };
+  const contextPayload = {
+    ...corePayload,
+    node: summary,
+    metrics
+  };
+  log26.info(`Context for ${nodeId}: ${metrics.estimatedTokens} tokens, ${metrics.reductionPercent}% reduction`);
+  return contextPayload;
+}
+var log26, KEY_MAP, KEY_LEGEND;
+var init_compact_context = __esm({
+  "src/core/context/compact-context.ts"() {
+    init_esm_shims();
+    init_ac_helpers();
+    init_token_estimator();
+    init_logger();
+    log26 = createLogger({ layer: "core", source: "compact-context.ts" });
+    KEY_MAP = {
+      // TaskContext top-level
+      task: "tk",
+      node: "n",
+      parent: "par",
+      children: "ch",
+      blockers: "bl",
+      dependsOn: "dep",
+      acceptanceCriteria: "ac",
+      sourceRef: "sr",
+      relatedNodes: "rel",
+      implementsNodes: "impl",
+      derivedFromNodes: "drv",
+      edgeParent: "ep",
+      edgeChildren: "ech",
+      metrics: "m",
+      // TaskSummary / shared fields
+      id: "i",
+      type: "t",
+      title: "n",
+      status: "s",
+      priority: "p",
+      description: "d",
+      sprint: "sp",
+      xpSize: "xs",
+      tags: "tg",
+      // BlockerInfo / DependencyInfo
+      relationType: "rt",
+      inferred: "inf",
+      resolved: "res",
+      // SourceRefInfo
+      file: "f",
+      startLine: "sl",
+      endLine: "el",
+      confidence: "cf",
+      // ContextMetrics
+      originalChars: "oc",
+      compactChars: "cc",
+      reductionPercent: "rp",
+      estimatedTokens: "et"
+    };
+    KEY_LEGEND = {};
+    for (const [full, short] of Object.entries(KEY_MAP)) {
+      KEY_LEGEND[short] = full;
+    }
+  }
+});
+
+// src/core/context/topological-decay.ts
+function corePayloadTokens(ctx, pinned) {
+  const { metrics: _m, node: _n, ...core } = ctx;
+  return estimateTokens2(JSON.stringify(pinned.length > 0 ? { ...core, pinnedInvariants: pinned } : core));
+}
+function isPinnedType(type, pinnedTypes) {
+  return pinnedTypes.has(type);
+}
+function collectDistantInvariants(store2, rootId, alreadyPresent, maxDepth, pinnedTypes) {
+  if (maxDepth <= 0) return [];
+  const visited = /* @__PURE__ */ new Set([rootId]);
+  const found = /* @__PURE__ */ new Map();
+  let frontier = [rootId];
+  for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth += 1) {
+    const next = [];
+    for (const id of frontier) {
+      const edges = [...store2.getEdgesFrom(id), ...store2.getEdgesTo(id)];
+      for (const edge of edges) {
+        const neighborId = edge.from === id ? edge.to : edge.from;
+        if (visited.has(neighborId)) continue;
+        visited.add(neighborId);
+        next.push(neighborId);
+        if (alreadyPresent.has(neighborId) || found.has(neighborId)) continue;
+        const neighbor = store2.getNodeById(neighborId);
+        if (neighbor && isPinnedType(neighbor.type, pinnedTypes)) {
+          found.set(neighborId, {
+            id: neighbor.id,
+            type: neighbor.type,
+            title: neighbor.title,
+            status: neighbor.status,
+            distance: depth
+          });
+        }
+      }
+    }
+    frontier = next;
+  }
+  return [...found.values()];
+}
+function buildDecayedTaskContext(store2, nodeId, opts) {
+  const base = buildTaskContext(store2, nodeId);
+  if (!base) return null;
+  const pinnedTypes = opts.pinnedTypes ?? new Set(DEFAULT_PINNED_TYPES);
+  const tokensBaseline = corePayloadTokens(base, []);
+  const peripheralWeight = decayWeight(opts.lambda, PERIPHERAL_DISTANCE);
+  const peripheralSurvives = peripheralWeight >= opts.weightThreshold;
+  const presentIds = /* @__PURE__ */ new Set([base.task.id]);
+  if (base.parent) presentIds.add(base.parent.id);
+  for (const c of base.children) presentIds.add(c.id);
+  for (const b of base.blockers) presentIds.add(b.id);
+  for (const d of base.dependsOn) presentIds.add(d.id);
+  const ctx = structuredClone(base);
+  let prunedCount = 0;
+  const prunePeripheral = (list) => {
+    if (!list) return list;
+    const kept = list.filter((item) => {
+      presentIds.add(item.id);
+      if (isPinnedType(item.type, pinnedTypes)) return true;
+      if (peripheralSurvives) return true;
+      prunedCount += 1;
+      return false;
+    });
+    return kept.length > 0 ? kept : void 0;
+  };
+  ctx.relatedNodes = prunePeripheral(ctx.relatedNodes);
+  ctx.implementsNodes = prunePeripheral(ctx.implementsNodes);
+  ctx.derivedFromNodes = prunePeripheral(ctx.derivedFromNodes);
+  ctx.edgeChildren = prunePeripheral(ctx.edgeChildren);
+  if (ctx.edgeParent) {
+    presentIds.add(ctx.edgeParent.id);
+    if (!isPinnedType(ctx.edgeParent.type, pinnedTypes) && !peripheralSurvives) {
+      ctx.edgeParent = null;
+      prunedCount += 1;
+    }
+  }
+  const pinnedInvariants = collectDistantInvariants(
+    store2,
+    nodeId,
+    presentIds,
+    opts.maxDepth,
+    pinnedTypes
+  );
+  const tokensActual = corePayloadTokens(ctx, pinnedInvariants);
+  ctx.metrics = {
+    ...ctx.metrics,
+    estimatedTokens: tokensActual
+  };
+  ctx.node = ctx.task;
+  const retainedCount = (ctx.children?.length ?? 0) + (ctx.blockers?.length ?? 0) + (ctx.dependsOn?.length ?? 0) + (ctx.relatedNodes?.length ?? 0) + (ctx.implementsNodes?.length ?? 0) + (ctx.derivedFromNodes?.length ?? 0) + (ctx.edgeChildren?.length ?? 0);
+  log27.debug("flow:decay", {
+    nodeId,
+    lambda: opts.lambda,
+    prunedCount,
+    pinnedCount: pinnedInvariants.length,
+    tokensBaseline,
+    tokensActual
+  });
+  return {
+    context: ctx,
+    meta: {
+      lambda: opts.lambda,
+      prunedCount,
+      retainedCount,
+      pinnedCount: pinnedInvariants.length,
+      tokensBaseline,
+      tokensActual,
+      tokensSaved: tokensBaseline - tokensActual,
+      pinnedInvariants
+    }
+  };
+}
+var log27, DEFAULT_PINNED_TYPES, PERIPHERAL_DISTANCE;
+var init_topological_decay = __esm({
+  "src/core/context/topological-decay.ts"() {
+    init_esm_shims();
+    init_compact_context();
+    init_flow_index();
+    init_token_estimator();
+    init_logger();
+    log27 = createLogger({ layer: "core", source: "topological-decay.ts" });
+    DEFAULT_PINNED_TYPES = [
+      "constraint",
+      "risk",
+      "decision",
+      "acceptance_criteria",
+      "constitution",
+      "requirement"
+    ];
+    PERIPHERAL_DISTANCE = 2;
+  }
+});
+
+// src/core/store/episodic-outcomes-store.ts
+function buildApproachSummary(touchedFiles, acIds) {
+  const files = [...touchedFiles].sort().join("+");
+  const acs = [...acIds].sort().join(",");
+  return `${files}:${acs}`;
+}
+function insertEpisodicOutcome(db, outcome) {
+  db.prepare(
+    `INSERT OR IGNORE INTO episodic_outcomes
+       (id, node_id, task_type, tags, approach_summary, outcome, cycle_time_delta, reopen_count, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    outcome.id,
+    outcome.nodeId,
+    outcome.taskType,
+    outcome.tags,
+    outcome.approachSummary,
+    outcome.outcome,
+    outcome.cycleTimeDelta,
+    outcome.reopenCount,
+    outcome.createdAt
+  );
+}
+function queryEpisodicOutcomes(db, opts = {}) {
+  const conditions = [];
+  const params = [];
+  if (opts.taskType) {
+    conditions.push("task_type = ?");
+    params.push(opts.taskType);
+  }
+  if (opts.maxAgeDays) {
+    const cutoff = Date.now() - opts.maxAgeDays * 24 * 3600 * 1e3;
+    conditions.push("created_at >= ?");
+    params.push(cutoff);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = Math.min(opts.limit ?? 100, 500);
+  params.push(limit);
+  const rows = db.prepare(
+    `SELECT id, node_id, task_type, tags, approach_summary, outcome,
+            cycle_time_delta, reopen_count, created_at
+     FROM episodic_outcomes
+     ${where}
+     ORDER BY created_at DESC
+     LIMIT ?`
+  ).all(...params);
+  return rows.map((r) => ({
+    id: r.id,
+    nodeId: r.node_id,
+    taskType: r.task_type,
+    tags: r.tags,
+    approachSummary: r.approach_summary,
+    outcome: r.outcome,
+    cycleTimeDelta: r.cycle_time_delta,
+    reopenCount: r.reopen_count,
+    createdAt: r.created_at
+  }));
+}
+var init_episodic_outcomes_store = __esm({
+  "src/core/store/episodic-outcomes-store.ts"() {
+    init_esm_shims();
+  }
+});
+
+// src/core/context/flow-metrics-store.ts
+function insertFlowMetric(db, metric) {
+  db.prepare(
+    `INSERT OR IGNORE INTO flow_metrics
+       (id, project_id, node_id, mode, phi, lambda,
+        tokens_baseline, tokens_actual, pruned_count, pinned_count, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    metric.id,
+    metric.projectId,
+    metric.nodeId,
+    metric.mode,
+    metric.phi,
+    metric.lambda,
+    metric.tokensBaseline,
+    metric.tokensActual,
+    metric.prunedCount,
+    metric.pinnedCount,
+    metric.createdAt
+  );
+}
+var init_flow_metrics_store = __esm({
+  "src/core/context/flow-metrics-store.ts"() {
+    init_esm_shims();
+  }
+});
+
+// src/core/context/flow-compact.ts
+function formatFlowContext(result) {
+  const { context: ctx, pinnedInvariants } = result;
+  const lines = ["Contexto do grafo (dilu\xEDdo por flow \u2014 \u03A6 governando o esquecimento):"];
+  lines.push(`- Task: ${ctx.task.title} (${ctx.task.id}) [${ctx.task.status}]`);
+  if (ctx.task.description) lines.push(`  ${ctx.task.description}`);
+  if (ctx.acceptanceCriteria.length > 0) {
+    lines.push("- Crit\xE9rios de aceita\xE7\xE3o:");
+    for (const ac of ctx.acceptanceCriteria) lines.push(`  \u2022 ${ac}`);
+  }
+  const openBlockers = ctx.blockers.filter((b) => b.status !== "done");
+  if (openBlockers.length > 0) {
+    lines.push(`- Bloqueadores: ${openBlockers.map((b) => `${b.title} (${b.status})`).join("; ")}`);
+  }
+  const openDeps = ctx.dependsOn.filter((d) => !d.resolved);
+  if (openDeps.length > 0) {
+    lines.push(`- Depende de: ${openDeps.map((d) => `${d.title} (${d.status})`).join("; ")}`);
+  }
+  if (pinnedInvariants.length > 0) {
+    lines.push("- Invariantes pinados (nunca dilu\xEDdos):");
+    for (const inv of pinnedInvariants) lines.push(`  \u2022 [${inv.type}] ${inv.title}`);
+  }
+  return lines.join("\n");
+}
+function recordMetric(store2, row) {
+  try {
+    insertFlowMetric(store2.getDb(), {
+      id: generateId("flowm"),
+      createdAt: row.createdAt ?? Date.now(),
+      ...row
+    });
+  } catch (err) {
+    log28.warn("flow:metric:record-failed", { error: err instanceof Error ? err.message : String(err) });
+  }
+}
+function applyFlowToCompact(store2, nodeId) {
+  const cfg = resolveFlowConfig(store2);
+  if (!cfg.enabled) return null;
+  const projectId = store2.getActiveProject()?.id ?? "unknown";
+  const outcomes = queryEpisodicOutcomes(store2.getDb(), { limit: cfg.historyWindow }).map((o) => o.outcome);
+  const state = computeFlowIndex(outcomes, {
+    emaGain: cfg.emaGain,
+    resetFactor: cfg.resetFactor,
+    partialFactor: cfg.partialFactor
+  });
+  const lambda = computeLambdaFlow(state.phi, cfg.lambdaBase, cfg.alpha);
+  const mode = cfg.experiment.abEnabled ? flowAbArm(nodeId) : "flow_on";
+  if (mode === "flow_off") {
+    const base = buildTaskContext(store2, nodeId);
+    if (!base) return null;
+    const baseline = base.metrics.estimatedTokens;
+    recordMetric(store2, {
+      projectId,
+      nodeId,
+      mode,
+      phi: state.phi,
+      lambda,
+      tokensBaseline: baseline,
+      tokensActual: baseline,
+      prunedCount: 0,
+      pinnedCount: 0
+    });
+    return {
+      context: base,
+      pinnedInvariants: [],
+      flow: {
+        enabled: true,
+        mode,
+        phi: state.phi,
+        streak: state.streak,
+        lambda,
+        prunedCount: 0,
+        pinnedCount: 0,
+        tokensBaseline: baseline,
+        tokensActual: baseline,
+        tokensSaved: 0
+      }
+    };
+  }
+  const decayed = buildDecayedTaskContext(store2, nodeId, {
+    lambda,
+    maxDepth: cfg.maxDepth,
+    weightThreshold: cfg.weightThreshold,
+    pinnedTypes: new Set(cfg.pinnedTypes)
+  });
+  if (!decayed) return null;
+  recordMetric(store2, {
+    projectId,
+    nodeId,
+    mode,
+    phi: state.phi,
+    lambda,
+    tokensBaseline: decayed.meta.tokensBaseline,
+    tokensActual: decayed.meta.tokensActual,
+    prunedCount: decayed.meta.prunedCount,
+    pinnedCount: decayed.meta.pinnedCount
+  });
+  return {
+    context: decayed.context,
+    pinnedInvariants: decayed.meta.pinnedInvariants,
+    flow: {
+      enabled: true,
+      mode,
+      phi: state.phi,
+      streak: state.streak,
+      lambda,
+      prunedCount: decayed.meta.prunedCount,
+      pinnedCount: decayed.meta.pinnedCount,
+      tokensBaseline: decayed.meta.tokensBaseline,
+      tokensActual: decayed.meta.tokensActual,
+      tokensSaved: decayed.meta.tokensSaved
+    }
+  };
+}
+var log28;
+var init_flow_compact = __esm({
+  "src/core/context/flow-compact.ts"() {
+    init_esm_shims();
+    init_flow_config();
+    init_flow_index();
+    init_topological_decay();
+    init_compact_context();
+    init_episodic_outcomes_store();
+    init_flow_metrics_store();
+    init_id();
+    init_logger();
+    log28 = createLogger({ layer: "core", source: "flow-compact.ts" });
+  }
+});
 
 // src/cli/shared/live-implement.ts
 function buildLiveImplement(options) {
@@ -7589,6 +8588,14 @@ function buildLiveImplement(options) {
   const repoRelations = projectId ? codeStore.getAllRelations(projectId) : [];
   const implement = async (node) => {
     const repoMap = repoSymbols.length > 0 ? buildRepoMap({ symbols: repoSymbols, relations: repoRelations }, { tokenBudget: REPO_MAP_TOKEN_BUDGET, focus: node.title }).text : void 0;
+    let flowContext;
+    const flow = applyFlowToCompact(store2, node.id);
+    if (flow) {
+      flowContext = formatFlowContext(flow);
+      onLog?.(
+        `  [flow] \u03A6=${flow.flow.phi.toFixed(2)} \u03BB=${flow.flow.lambda.toFixed(2)} podados=${flow.flow.prunedCount} pinados=${flow.flow.pinnedCount} \u2192 ${flow.flow.tokensSaved} tok economizados`
+      );
+    }
     const outcome = await attemptImplementation(
       {
         generate: async (prompt) => {
@@ -7604,13 +8611,28 @@ function buildLiveImplement(options) {
         },
         execute: (plan) => executePlan(plan, { workspaceDir: dir, defaultTestCommand: testCmd })
       },
-      { node, maxAttempts, repoMap }
+      { node, maxAttempts, repoMap, flowContext }
     );
     const files = outcome.lastResult?.applied.length ?? 0;
     const task = ledger.byTask(node.id);
     onLog?.(
       `  [live] ${client.modelFor("implement")}: ${outcome.attempts} tentativa(s), ${files} arquivo(s), ${task.total} tok \u2192 ${outcome.success ? "verde" : "escala"}`
     );
+    try {
+      const applied = outcome.lastResult?.applied ?? [];
+      insertEpisodicOutcome(store2.getDb(), {
+        id: generateId("epi"),
+        nodeId: node.id,
+        taskType: "",
+        tags: "",
+        approachSummary: buildApproachSummary(applied, []),
+        outcome: outcome.success ? "success" : "failure",
+        cycleTimeDelta: 0,
+        reopenCount: 0,
+        createdAt: Date.now()
+      });
+    } catch {
+    }
     return outcome.success;
   };
   return { implement, repoSymbolCount: repoSymbols.length };
@@ -7625,6 +8647,9 @@ var init_live_implement = __esm({
     init_implement_attempt();
     init_code_store();
     init_repo_map();
+    init_flow_compact();
+    init_episodic_outcomes_store();
+    init_id();
     REPO_MAP_TOKEN_BUDGET = 1e3;
   }
 });
@@ -7658,6 +8683,18 @@ var init_store_port = __esm({
     init_definition_of_done();
   }
 });
+
+// src/tui/status-line.ts
+function formatStatusLine(input) {
+  const tokens = `${Math.max(0, Math.round(input.totalTokens))} tok`;
+  const cost = `$${input.costUsd.toFixed(4)}`;
+  return `\u26C1 ${tokens} \xB7 ${cost} \xB7 ${input.model}`;
+}
+var init_status_line = __esm({
+  "src/tui/status-line.ts"() {
+    init_esm_shims();
+  }
+});
 function TaskRow({ task }) {
   return /* @__PURE__ */ jsxs(Text, { children: [
     "  ",
@@ -7684,6 +8721,7 @@ function App({ model }) {
       " ",
       model.wip
     ] }) }),
+    /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: "green", children: formatStatusLine({ totalTokens: model.tokens.total, costUsd: model.tokens.costUsd, model: model.modelLabel }) }) }),
     /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
       /* @__PURE__ */ jsxs(Text, { bold: true, children: [
         "Tasks ativas (",
@@ -7714,6 +8752,7 @@ var STATUS_ICON;
 var init_app = __esm({
   "src/tui/app.tsx"() {
     init_esm_shims();
+    init_status_line();
     STATUS_ICON = {
       in_progress: "\u25CF",
       ready: "\u25CB",
@@ -7764,6 +8803,7 @@ var init_banner_screen = __esm({
 function CommandBar({ value, onChange, onSubmit, suggestions }) {
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
     suggestions.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginBottom: 1, children: suggestions.map((c) => /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      c.source === "skill" ? /* @__PURE__ */ jsx(Text, { color: "magenta", children: "[skill] " }) : null,
       c.usage,
       " \u2014 ",
       c.desc
@@ -7780,6 +8820,28 @@ var init_command_bar = __esm({
   }
 });
 
+// src/tui/history.ts
+function valueAt(state, cursor) {
+  if (cursor < 0) return state.draft;
+  return state.history[state.history.length - 1 - cursor];
+}
+function navigateHistory(state, dir) {
+  const last = state.history.length - 1;
+  if (last < 0) return { value: state.draft, cursor: -1 };
+  let cursor = state.cursor;
+  if (dir === "up") {
+    cursor = Math.min(cursor + 1, last);
+  } else {
+    cursor = Math.max(cursor - 1, -1);
+  }
+  return { value: valueAt(state, cursor), cursor };
+}
+var init_history = __esm({
+  "src/tui/history.ts"() {
+    init_esm_shims();
+  }
+});
+
 // src/tui/dispatch.ts
 function parseCommand(input) {
   const trimmed = input.trim();
@@ -7789,11 +8851,38 @@ function parseCommand(input) {
   if (sp === -1) return { cmd: body.toLowerCase(), args: "" };
   return { cmd: body.slice(0, sp).toLowerCase(), args: body.slice(sp + 1).trim() };
 }
+function fuzzyScore(query, text) {
+  const q = query.toLowerCase();
+  const t = text.toLowerCase();
+  if (q === "") return 0;
+  let qi = 0;
+  let score = 0;
+  let lastMatch = -1;
+  for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+    if (t[ti] === q[qi]) {
+      if (lastMatch === -1) score += ti;
+      else score += ti - lastMatch - 1;
+      lastMatch = ti;
+      qi++;
+    }
+  }
+  return qi === q.length ? score : null;
+}
+function fuzzyFilter(query, commands) {
+  if (query.trim() === "") return [...commands];
+  const scored = [];
+  commands.forEach((cmd, idx) => {
+    const score = fuzzyScore(query, cmd.name);
+    if (score !== null) scored.push({ cmd, score, idx });
+  });
+  scored.sort((a, b) => a.score !== b.score ? a.score - b.score : a.idx - b.idx);
+  return scored.map((s) => s.cmd);
+}
 function filterCommands(input, extra = []) {
   const trimmed = input.trim();
   if (!trimmed.startsWith("/")) return [];
-  const prefix = trimmed.slice(1).split(" ")[0].toLowerCase();
-  return [...COMMANDS, ...extra].filter((c) => c.name.startsWith(prefix));
+  const query = trimmed.slice(1).split(" ")[0];
+  return fuzzyFilter(query, [...COMMANDS, ...extra]);
 }
 async function runAsyncCommand(port, parsed, _onLine) {
   switch (parsed.cmd) {
@@ -7890,15 +8979,30 @@ function InteractiveApp({ dashboard, port, asyncPort, liveRunner, skillCommands
     process.stdout.isTTY ? "banner" : "dashboard"
   );
   const [input, setInput] = useState("");
-  const [log45, setLog] = useState([]);
+  const [log48, setLog] = useState([]);
   const [running, setRunning] = useState(false);
   const [showHelp, setShowHelp] = useState(false);
+  const [history, setHistory] = useState([]);
+  const [histCursor, setHistCursor] = useState(-1);
+  const [draft, setDraft] = useState("");
   const append = (line) => setLog((prev) => [...prev, line].slice(-MAX_LOG_LINES));
+  useInput((_input, key) => {
+    if (phase !== "dashboard" || running) return;
+    if (!key.upArrow && !key.downArrow) return;
+    const effectiveDraft = histCursor === -1 ? input : draft;
+    if (histCursor === -1) setDraft(input);
+    const result = navigateHistory({ history, cursor: histCursor, draft: effectiveDraft }, key.upArrow ? "up" : "down");
+    setHistCursor(result.cursor);
+    setInput(result.value);
+  });
   const submit = (raw) => {
     const parsed = parseCommand(raw);
     setInput("");
     const text = raw.trim();
     if (text === "" || running) return;
+    setHistory((prev) => [...prev, text]);
+    setHistCursor(-1);
+    setDraft("");
     if (parsed.cmd === "quit") {
       exit();
       return;
@@ -7939,7 +9043,7 @@ ${skill.body}` : `Skill n\xE3o encontrada: ${parsed.cmd}`);
   }
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx(App, { model: dashboard }),
-    log45.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", paddingX: 1, children: log45.map((line, i) => /* @__PURE__ */ jsx(Text, { children: line }, i)) }),
+    log48.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", paddingX: 1, children: log48.map((line, i) => /* @__PURE__ */ jsx(Text, { children: line }, i)) }),
     showHelp && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", paddingX: 1, children: [
       /* @__PURE__ */ jsx(Text, { bold: true, children: "Comandos:" }),
       COMMANDS.map((c) => /* @__PURE__ */ jsxs(Text, { children: [
@@ -7962,6 +9066,7 @@ var init_interactive_app = __esm({
     init_app();
     init_banner_screen();
     init_command_bar();
+    init_history();
     init_dispatch();
     MAX_LOG_LINES = 12;
   }
@@ -8166,22 +9271,25 @@ function parseSkillMarkdown(content) {
   } catch (err) {
     return { ok: false, error: `YAML parse error: ${err instanceof Error ? err.message : String(err)}` };
   }
+  const rawTriggers = frontmatter.triggers;
+  const triggers = Array.isArray(rawTriggers) ? rawTriggers.map((t) => typeof t === "string" ? { event: t } : t) : rawTriggers;
+  const phases = Array.isArray(frontmatter.phases) ? frontmatter.phases : [];
   const raw = {
     name: frontmatter.name,
     description: frontmatter.description,
     category: frontmatter.category ?? "know-me",
-    phases: frontmatter.phases,
+    phases,
     // §extracta-sweep-1 — optional `platforms:` array; absent = all OSes.
     platforms: frontmatter.platforms,
     instructions: bodyText,
     toolchain: frontmatter.toolchain,
-    triggers: frontmatter.triggers,
+    triggers,
     contextTemplate: frontmatter.contextTemplate
   };
   const parsed = CustomSkillInputSchema.safeParse(raw);
   if (!parsed.success) {
     const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-    log26.warn("skill-loader:validation_failed", { issues });
+    log29.debug("skill-loader:validation_failed", { issues });
     return { ok: false, error: `Validation failed: ${issues}` };
   }
   return { ok: true, skill: parsed.data };
@@ -8224,13 +9332,13 @@ function walk(dir, acc) {
     else acc.errors.push({ file: full, error: parsed.error ?? "unknown parse error" });
   }
 }
-var log26;
+var log29;
 var init_skill_loader = __esm({
   "src/core/skills/skill-loader.ts"() {
     init_esm_shims();
     init_skill_schema();
     init_logger();
-    log26 = createLogger({ layer: "core", source: "skill-loader.ts" });
+    log29 = createLogger({ layer: "core", source: "skill-loader.ts" });
   }
 });
 function summarize(skill) {
@@ -8323,7 +9431,7 @@ function mergeGraph(store2, incoming, options) {
   }
   const sourceProject = incoming.project.name;
   const dryRun = options?.dryRun ?? false;
-  log27.info("merge-graph:start", {
+  log30.info("merge-graph:start", {
     sourceProject,
     incomingNodes: incoming.nodes.length,
     incomingEdges: incoming.edges.length,
@@ -8375,7 +9483,7 @@ function mergeGraph(store2, incoming, options) {
         edgesInserted2++;
       }
     }
-    log27.info("merge-graph:dry-run", {
+    log30.info("merge-graph:dry-run", {
       nodesInserted: nodesToInsert.length,
       nodesSkipped,
       edgesInserted: edgesInserted2,
@@ -8395,7 +9503,7 @@ function mergeGraph(store2, incoming, options) {
   const { nodesInserted, edgesInserted } = store2.mergeInsert(nodesToInsert, validEdges);
   const edgesSkipped = validEdges.length - edgesInserted;
   store2.recordImport(`merge:${sourceProject}`, nodesInserted, edgesInserted);
-  log27.info("merge-graph:done", {
+  log30.info("merge-graph:done", {
     sourceProject,
     nodesInserted,
     nodesSkipped,
@@ -8412,14 +9520,14 @@ function mergeGraph(store2, incoming, options) {
     sourceProject
   };
 }
-var log27;
+var log30;
 var init_import_graph = __esm({
   "src/core/importer/import-graph.ts"() {
     init_esm_shims();
     init_graph_schema();
     init_errors();
     init_logger();
-    log27 = createLogger({ layer: "core", source: "import-graph.ts" });
+    log30 = createLogger({ layer: "core", source: "import-graph.ts" });
   }
 });
 
@@ -8530,7 +9638,7 @@ function computeFileSha256(path22) {
   return hash.digest("hex");
 }
 async function downloadFileWithVerify(url, destPath, expectedSha256) {
-  log28.info("model-downloader:start", { url, dest: destPath, hasExpectedHash: false });
+  log31.info("model-downloader:start", { url, dest: destPath, hasExpectedHash: false });
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS);
   let response;
@@ -8552,15 +9660,15 @@ async function downloadFileWithVerify(url, destPath, expectedSha256) {
   const actualSha = computeFileSha256(destPath);
   const sizeBytes = statSync(destPath).size;
   const verified = expectedSha256 != null && actualSha === expectedSha256;
-  log28.info("model-downloader:ok", { dest: destPath, sizeBytes, sha256: actualSha, verified });
+  log31.info("model-downloader:ok", { dest: destPath, sizeBytes, sha256: actualSha, verified });
   return { sha256: actualSha, verified, sizeBytes };
 }
-var log28, DOWNLOAD_TIMEOUT_MS, ChecksumMismatchError, DownloadError;
+var log31, DOWNLOAD_TIMEOUT_MS, ChecksumMismatchError, DownloadError;
 var init_model_downloader = __esm({
   "src/core/rag/model-downloader.ts"() {
     init_esm_shims();
     init_logger();
-    log28 = createLogger({ layer: "core", source: "model-downloader.ts" });
+    log31 = createLogger({ layer: "core", source: "model-downloader.ts" });
     DOWNLOAD_TIMEOUT_MS = 9e4;
     ChecksumMismatchError = class extends Error {
       constructor(url, expected, actual) {
@@ -8629,15 +9737,15 @@ async function isOnnxAvailable() {
     onnxAvailableCache = true;
   } catch {
     onnxAvailableCache = false;
-    log29.warn("onnx:unavailable", { reason: "onnxruntime-node not installed \u2014 RAG will use hash embeddings (degraded mode)" });
+    log32.warn("onnx:unavailable", { reason: "onnxruntime-node not installed \u2014 RAG will use hash embeddings (degraded mode)" });
   }
   return onnxAvailableCache;
 }
 async function logEmbeddingModeOnBoot(isAvailable = isOnnxAvailable, logFn = (event, fields) => {
   if (fields.mode === "neural") {
-    log29.info(event, fields);
+    log32.info(event, fields);
   } else {
-    log29.warn(event, fields);
+    log32.warn(event, fields);
   }
 }) {
   try {
@@ -8660,7 +9768,7 @@ function ensureOnnxModelDir(modelsDir) {
 async function downloadFile(url, destPath) {
   try {
     const resultValue = await downloadFileWithVerify(url, destPath);
-    log29.info("onnx:download:ok", {
+    log32.info("onnx:download:ok", {
       dest: destPath,
       sizeBytes: resultValue.sizeBytes,
       sha256: resultValue.sha256,
@@ -8684,7 +9792,7 @@ async function ensureModelFiles(modelsDir) {
   if (existsSync(modelPath)) {
     const size = statSync(modelPath).size;
     if (size < MIN_MODEL_SIZE) {
-      log29.warn("onnx:corrupted-model", { modelPath, sizeBytes: size, minRequired: MIN_MODEL_SIZE });
+      log32.warn("onnx:corrupted-model", { modelPath, sizeBytes: size, minRequired: MIN_MODEL_SIZE });
       unlinkSync(modelPath);
     }
   }
@@ -8693,12 +9801,12 @@ async function ensureModelFiles(modelsDir) {
       const raw = readFileSync(tokenizerPath, "utf-8");
       JSON.parse(raw);
     } catch {
-      log29.warn("onnx:corrupted-tokenizer", { tokenizerPath });
+      log32.warn("onnx:corrupted-tokenizer", { tokenizerPath });
       unlinkSync(tokenizerPath);
     }
   }
   if (existsSync(modelPath) && existsSync(tokenizerPath)) {
-    log29.debug("onnx:cache-hit", { modelDir });
+    log32.debug("onnx:cache-hit", { modelDir });
     return { modelPath, tokenizerPath };
   }
   mkdirSync(modelDir, { recursive: true });
@@ -8715,7 +9823,7 @@ function loadTokenizer(tokenizerPath) {
     const raw = readFileSync(tokenizerPath, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
-    log29.warn("onnx:tokenizer-load-failed", { tokenizerPath, error: err instanceof Error ? err.message : String(err) });
+    log32.warn("onnx:tokenizer-load-failed", { tokenizerPath, error: err instanceof Error ? err.message : String(err) });
     return null;
   }
 }
@@ -8767,15 +9875,15 @@ function startOnnxBackgroundDownload(modelsDir, options = {}) {
         modelPath = join(modelDir, MODEL_FILENAME);
         tokenizerPath = join(modelDir, TOKENIZER_FILENAME);
         const cacheEvent = "onnx:background-ready-from-cache";
-        log29.info(cacheEvent, { modelsDir });
+        log32.info(cacheEvent, { modelsDir });
         onLog?.(cacheEvent);
       } else {
         const startEvent = "onnx:background-download-start";
-        log29.info(startEvent, { message: "Downloading MiniLM-L6-v2 (23MB)...", modelsDir });
+        log32.info(startEvent, { message: "Downloading MiniLM-L6-v2 (23MB)...", modelsDir });
         onLog?.(startEvent);
         ({ modelPath, tokenizerPath } = await ensureFiles(modelsDir));
         const doneEvent = "onnx:background-download-complete";
-        log29.info(doneEvent, { modelsDir });
+        log32.info(doneEvent, { modelsDir });
         onLog?.(doneEvent);
       }
       const provider = makeProvider(modelPath, tokenizerPath);
@@ -8783,7 +9891,7 @@ function startOnnxBackgroundDownload(modelsDir, options = {}) {
       onReady?.(provider);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      log29.warn("onnx:background-download-failed", { error: msg, action: "fallback-remains-tfidf" });
+      log32.warn("onnx:background-download-failed", { error: msg, action: "fallback-remains-tfidf" });
       onWarning?.(msg);
     }
   };
@@ -8797,7 +9905,7 @@ function _resetBackgroundDownloadState() {
 async function getOnnxProvider(modelsDir) {
   const available = await isOnnxAvailable();
   if (!available) {
-    log29.warn("onnx:provider-degraded", { available: false, impact: "RAG operates with hash embeddings instead of neural \u2014 lower search quality" });
+    log32.warn("onnx:provider-degraded", { available: false, impact: "RAG operates with hash embeddings instead of neural \u2014 lower search quality" });
     return null;
   }
   const existing = providerCache.get(modelsDir);
@@ -8817,8 +9925,8 @@ async function getOnnxProvider(modelsDir) {
     return await creation;
   } catch (err) {
     providerCache.delete(modelsDir);
-    log29.error("onnx:provider-init-failed", { error: err instanceof Error ? err.message : String(err) });
-    log29.warn("onnx:fallback", {
+    log32.error("onnx:provider-init-failed", { error: err instanceof Error ? err.message : String(err) });
+    log32.warn("onnx:fallback", {
       reason: err instanceof Error ? err.message : String(err),
       action: "return-null-provider",
       modelsDir
@@ -8826,7 +9934,7 @@ async function getOnnxProvider(modelsDir) {
     return null;
   }
 }
-var log29, MODEL_NAME, MODEL_FILENAME, TOKENIZER_FILENAME, EMBEDDING_DIM, MAX_SEQUENCE_LENGTH, MODEL_BASE_URL, MODEL_URL, TOKENIZER_URL, DOWNLOAD_TIMEOUT_MS2, onnxAvailableCache, OnnxEmbeddingProvider, _backgroundProvider, _backgroundStarted, providerCache;
+var log32, MODEL_NAME, MODEL_FILENAME, TOKENIZER_FILENAME, EMBEDDING_DIM, MAX_SEQUENCE_LENGTH, MODEL_BASE_URL, MODEL_URL, TOKENIZER_URL, DOWNLOAD_TIMEOUT_MS2, onnxAvailableCache, OnnxEmbeddingProvider, _backgroundProvider, _backgroundStarted, providerCache;
 var init_onnx_embeddings = __esm({
   "src/core/rag/onnx-embeddings.ts"() {
     init_esm_shims();
@@ -8834,7 +9942,7 @@ var init_onnx_embeddings = __esm({
     init_errors();
     init_tensor_buffer_pool();
     init_model_downloader();
-    log29 = createLogger({ layer: "rag", source: "onnx-embeddings.ts" });
+    log32 = createLogger({ layer: "rag", source: "onnx-embeddings.ts" });
     MODEL_NAME = "all-MiniLM-L6-v2-quantized";
     MODEL_FILENAME = "model.onnx";
     TOKENIZER_FILENAME = "tokenizer.json";
@@ -8866,7 +9974,7 @@ var init_onnx_embeddings = __esm({
           throw new OnnxModelNotFoundError(`Failed to load tokenizer: ${this.tokenizerPath}`);
         }
         this.vocab = config.model?.vocab ?? {};
-        log29.info("onnx:session-created", { model: this.modelPath });
+        log32.info("onnx:session-created", { model: this.modelPath });
         return this.session;
       }
       async generateEmbedding(text) {
@@ -8995,7 +10103,7 @@ async function checkSqliteDatabase(basePath) {
       };
     }
   } catch (err) {
-    log30.debug("intentional-swallow", { error: String(err), reason: "statSync race with deletion; fall through to open attempt" });
+    log33.debug("intentional-swallow", { error: String(err), reason: "statSync race with deletion; fall through to open attempt" });
   }
   try {
     const db = new Database2(dbPath, { readonly: true });
@@ -9045,7 +10153,7 @@ async function checkDbIntegrity2(basePath) {
       };
     }
   } catch (err) {
-    log30.debug("intentional-swallow", { error: String(err), reason: "fall through to open attempt" });
+    log33.debug("intentional-swallow", { error: String(err), reason: "fall through to open attempt" });
   }
   try {
     const db = new Database2(dbPath, { readonly: true });
@@ -9053,7 +10161,7 @@ async function checkDbIntegrity2(basePath) {
     try {
       schemaCount = db.prepare("SELECT count(*) as n FROM sqlite_master WHERE type IN ('table','view')").get().n;
     } catch (err) {
-      log30.debug("intentional-swallow", { error: String(err), reason: "reading sqlite_master itself failed \u2014 DB is unreadable, fall through" });
+      log33.debug("intentional-swallow", { error: String(err), reason: "reading sqlite_master itself failed \u2014 DB is unreadable, fall through" });
     }
     if (schemaCount === 0) {
       db.close();
@@ -9213,7 +10321,7 @@ async function checkIntegrations(basePath) {
     });
     return results;
   } catch (err) {
-    log30.debug("doctor:integrations:fail", {
+    log33.debug("doctor:integrations:fail", {
       error: err instanceof Error ? err.message : String(err)
     });
     return [
@@ -9264,7 +10372,7 @@ async function checkOnnxStatus() {
   const { isOnnxAvailable: isOnnxAvailable2 } = await Promise.resolve().then(() => (init_onnx_embeddings(), onnx_embeddings_exports));
   return checkOnnxStatusWith(isOnnxAvailable2);
 }
-var log30, MIN_NODE_VERSION;
+var log33, MIN_NODE_VERSION;
 var init_doctor_checks = __esm({
   "src/core/doctor/doctor-checks.ts"() {
     init_esm_shims();
@@ -9272,7 +10380,7 @@ var init_doctor_checks = __esm({
     init_fs();
     init_tool_status();
     init_logger();
-    log30 = createLogger({ layer: "core", source: "doctor-checks.ts" });
+    log33 = createLogger({ layer: "core", source: "doctor-checks.ts" });
     MIN_NODE_VERSION = 20;
   }
 });
@@ -9297,7 +10405,7 @@ async function runDoctor(basePath) {
   if (!basePath) {
     throw new McpGraphError("Doctor requires a valid base path");
   }
-  log31.info("Running doctor checks", { basePath });
+  log34.info("Running doctor checks", { basePath });
   const checks = [];
   checks.push(checkNodeVersion());
   checks.push(checkConfigFile(basePath));
@@ -9335,7 +10443,7 @@ async function runDoctor(basePath) {
     }
   }
   for (const result of checks) {
-    log31.event(
+    log34.event(
       { action: "health.check", category: "health", outcome: result.level === "ok" ? "success" : "failure" },
       `health.check.${result.name}`,
       { check: result.name }
@@ -9348,7 +10456,7 @@ async function runDoctor(basePath) {
     passed: summary.error === 0
   };
 }
-var log31;
+var log34;
 var init_doctor_runner = __esm({
   "src/core/doctor/doctor-runner.ts"() {
     init_esm_shims();
@@ -9357,7 +10465,7 @@ var init_doctor_runner = __esm({
     init_errors();
     init_logger();
     init_doctor_checks();
-    log31 = createLogger({ layer: "core", source: "doctor-runner.ts" });
+    log34 = createLogger({ layer: "core", source: "doctor-runner.ts" });
   }
 });
 
@@ -9490,7 +10598,8 @@ async function launchTui(store2) {
     return skills.map((s) => ({
       name: s.name,
       usage: `/${s.name}`,
-      desc: `[${s.category}] ${s.description}`
+      desc: `[${s.category}] ${s.description}`,
+      source: "skill"
     }));
   });
   const instance = render(
@@ -10104,16 +11213,36 @@ init_token_ledger();
 init_llm_call_ledger();
 init_live_implement();
 init_store_port();
+
+// src/cli/shared/enable-flow.ts
+init_esm_shims();
+init_flow_config();
+function enableFlowConfig(store2) {
+  const raw = store2.getProjectSetting(FLOW_CONFIG_SETTING_KEY);
+  let current = {};
+  if (raw) {
+    try {
+      current = JSON.parse(raw);
+    } catch {
+      current = {};
+    }
+  }
+  store2.setProjectSetting(FLOW_CONFIG_SETTING_KEY, JSON.stringify({ ...current, enabled: true }));
+}
 function output7(msg) {
   process.stdout.write(msg + "\n");
 }
 function autopilotCommand() {
-  return new Command("autopilot").description("Loop aut\xF4nomo com guardrails: next \u2192 in_progress \u2192 DoD \u2192 done|escalate (WIP=1)").option("-d, --dir <dir>", "Diret\xF3rio do projeto", process.cwd()).option("-m, --max <n>", "Budget: m\xE1ximo de tasks por sess\xE3o (cost-runaway guard)", "5").option("--simulate", "Simula impl bem-sucedida (deixa o DoD real decidir) \u2014 n\xE3o escreve c\xF3digo", false).option("--live", "Invoca o modelo real via SDK do Copilot: gera plano \u2192 aplica \u2192 roda testes \u2192 done|escala", false).option("--test-cmd <cmd>", "Comando de teste rodado no modo --live quando o plano n\xE3o traz um", "npm test").option("--retries <n>", "Tentativas por task no --live (retry com feedback compacto do teste)", "2").action(
+  return new Command("autopilot").description("Loop aut\xF4nomo com guardrails: next \u2192 in_progress \u2192 DoD \u2192 done|escalate (WIP=1)").option("-d, --dir <dir>", "Diret\xF3rio do projeto", process.cwd()).option("-m, --max <n>", "Budget: m\xE1ximo de tasks por sess\xE3o (cost-runaway guard)", "5").option("--simulate", "Simula impl bem-sucedida (deixa o DoD real decidir) \u2014 n\xE3o escreve c\xF3digo", false).option("--live", "Invoca o modelo real via SDK do Copilot: gera plano \u2192 aplica \u2192 roda testes \u2192 done|escala", false).option("--test-cmd <cmd>", "Comando de teste rodado no modo --live quando o plano n\xE3o traz um", "npm test").option("--retries <n>", "Tentativas por task no --live (retry com feedback compacto do teste)", "2").option("--flow", "Ativa a dilui\xE7\xE3o de contexto por \u03BB_flow (hipofrontalidade) no --live", false).action(
     async (opts) => {
       const store2 = openStoreOrFail(opts.dir, { requireExisting: true });
       try {
         const maxIterations = Math.max(1, parseInt(opts.max, 10) || 5);
         const port = makeStorePort(store2);
+        if (opts.flow) {
+          enableFlowConfig(store2);
+          output7("[FLOW] \u03BB_flow ativo: contexto do grafo dilu\xEDdo por \u03A6(t) (esquecimento din\xE2mico).\n");
+        }
         if (opts.simulate) output7("[SIMULA\xC7\xC3O] impl tratada como verde \u2014 DoD real decide prontid\xE3o.\n");
         if (opts.live) output7("[LIVE] modelo via SDK do Copilot: gera plano \u2192 aplica no workspace \u2192 roda testes.\n");
         let implement;
@@ -10413,7 +11542,7 @@ function whichCommand() {
 }
 
 // src/core/lsp/lsp-deps-installer.ts
-var log33 = createLogger({ layer: "core", source: "lsp-deps-installer.ts" });
+var log36 = createLogger({ layer: "core", source: "lsp-deps-installer.ts" });
 var execAsync = promisify(execFile);
 var LSP_NPM_PACKAGES = {
   typescript: "typescript-language-server",
@@ -10464,7 +11593,7 @@ var LSP_SYSTEM_PACKAGES = {
 async function checkLspDep(languageId, command) {
   try {
     await execAsync(whichCommand(), [command]);
-    log33.info("LSP server available", { languageId, command });
+    log36.info("LSP server available", { languageId, command });
     return {
       name: command,
       languageId,
@@ -10510,7 +11639,7 @@ function getServerCommand(languageId) {
 }
 async function installLspDeps(detectedLanguages) {
   if (detectedLanguages.length === 0) return [];
-  log33.info("Checking LSP server dependencies", {
+  log36.info("Checking LSP server dependencies", {
     languages: detectedLanguages.join(", ")
   });
   const results = [];
@@ -10522,7 +11651,7 @@ async function installLspDeps(detectedLanguages) {
   }
   const available = results.filter((r) => r.status === "already_available").length;
   const missing = results.filter((r) => r.status === "not_found").length;
-  log33.info("LSP dependency check complete", {
+  log36.info("LSP dependency check complete", {
     total: String(results.length),
     available: String(available),
     missing: String(missing)
@@ -10533,7 +11662,7 @@ async function installLspDeps(detectedLanguages) {
 // src/core/lsp/language-detector.ts
 init_esm_shims();
 init_logger();
-var log34 = createLogger({ layer: "core", source: "language-detector.ts" });
+var log37 = createLogger({ layer: "core", source: "language-detector.ts" });
 var CONFIG_FILE_MAP = {
   "tsconfig.json": "typescript",
   "jsconfig.json": "typescript",
@@ -10573,7 +11702,7 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "__pycache__"
 ]);
 function detectProjectLanguages(projectPath, registry) {
-  log34.debug("detecting project languages", { projectPath });
+  log37.debug("detecting project languages", { projectPath });
   const configDetections = /* @__PURE__ */ new Map();
   const fileCounts = /* @__PURE__ */ new Map();
   detectConfigFiles(projectPath, configDetections);
@@ -10601,7 +11730,7 @@ function detectProjectLanguages(projectPath, registry) {
     });
   }
   results.sort((a, b) => b.fileCount - a.fileCount);
-  log34.info("project languages detected", {
+  log37.info("project languages detected", {
     count: String(results.length),
     languages: results.map((r) => r.languageId).join(",")
   });
@@ -10612,7 +11741,7 @@ function detectConfigFiles(rootPath, configDetections) {
   try {
     entries = readdirSync(rootPath, { withFileTypes: true, encoding: "utf-8" });
   } catch {
-    log34.debug("cannot read root directory for config detection", { rootPath });
+    log37.debug("cannot read root directory for config detection", { rootPath });
     return;
   }
   for (const entry of entries) {
@@ -10637,7 +11766,7 @@ function walkAndCountFiles(dirPath, registry, fileCounts) {
   try {
     entries = readdirSync(dirPath, { withFileTypes: true, encoding: "utf-8" });
   } catch {
-    log34.debug("cannot read directory, skipping", { dirPath });
+    log37.debug("cannot read directory, skipping", { dirPath });
     return;
   }
   for (const entry of entries) {
@@ -11722,176 +12851,10 @@ function applySection(existingContent, newSection) {
 
 // src/core/config/config-loader.ts
 init_esm_shims();
-
-// src/core/config/config-schema.ts
-init_esm_shims();
-
-// src/core/lsp/lsp-types.ts
-init_esm_shims();
-z.object({
-  languageId: z.string(),
-  extensions: z.array(z.string()),
-  command: z.string(),
-  args: z.array(z.string()),
-  configFiles: z.array(z.string()),
-  probeCommand: z.string().optional(),
-  initializationOptions: z.record(z.string(), z.unknown()).optional(),
-  settings: z.record(z.string(), z.unknown()).optional()
-});
-var LspConfigOverrideSchema = z.object({
-  languageId: z.string(),
-  command: z.string(),
-  args: z.array(z.string()).default([]),
-  extensions: z.array(z.string()).optional(),
-  initializationOptions: z.record(z.string(), z.unknown()).optional(),
-  settings: z.record(z.string(), z.unknown()).optional()
-});
-z.object({
-  file: z.string(),
-  startLine: z.int().min(0),
-  startCharacter: z.int().min(0),
-  endLine: z.int().min(0),
-  endCharacter: z.int().min(0)
-});
-z.object({
-  signature: z.string(),
-  documentation: z.string().optional(),
-  language: z.string().optional()
-});
-var LspDiagnosticSchema = z.object({
-  file: z.string(),
-  startLine: z.int().min(0),
-  startCharacter: z.int().min(0),
-  endLine: z.int().min(0),
-  endCharacter: z.int().min(0),
-  severity: z.number().int().min(1).max(4),
-  message: z.string(),
-  code: z.string().optional(),
-  source: z.string().optional()
-});
-z.object({
-  name: z.string(),
-  kind: z.string(),
-  file: z.string(),
-  startLine: z.int().min(0),
-  endLine: z.int().min(0)
-});
-var LspDocumentSymbolSchema = z.object({
-  name: z.string(),
-  kind: z.string(),
-  file: z.string(),
-  startLine: z.int().min(0),
-  endLine: z.int().min(0),
-  children: z.lazy(() => z.array(LspDocumentSymbolSchema)).optional()
-});
-var LspTextEditSchema = z.object({
-  file: z.string(),
-  startLine: z.int().min(0),
-  startCharacter: z.int().min(0),
-  endLine: z.int().min(0),
-  endCharacter: z.int().min(0),
-  newText: z.string()
-});
-var LspWorkspaceEditSchema = z.object({
-  changes: z.array(LspTextEditSchema)
-});
-z.object({
-  languageId: z.string(),
-  status: z.enum(["stopped", "starting", "ready", "error"]),
-  pid: z.number().int().optional(),
-  error: z.string().optional()
-});
-z.object({
-  languageId: z.string(),
-  confidence: z.number().min(0).max(1),
-  detectedVia: z.enum(["file_extension", "config_file", "shebang"]),
-  fileCount: z.int().min(0),
-  configFile: z.string().optional()
-});
-z.object({
-  title: z.string(),
-  kind: z.string().optional(),
-  isPreferred: z.boolean().optional(),
-  edit: LspWorkspaceEditSchema.optional(),
-  diagnostics: z.array(LspDiagnosticSchema).optional()
-});
-z.object({
-  applied: z.boolean(),
-  filesModified: z.array(z.string()),
-  totalEdits: z.number().int(),
-  errors: z.array(z.string()),
-  backups: z.map(z.string(), z.string()).optional()
-});
-
-// src/core/config/config-schema.ts
-var BROWSER_PILOT_MODELS = ["claude-3.5-sonnet", "gpt-4o", "gpt-4o-mini", "o1", "o1-mini"];
-var ContextModeSchema = z.enum(["ultra-lean", "lean", "full"]);
-var ProfileFilterConfigSchema = z.enum(["core", "pro", "expert", "all"]);
-var BrowserAutomationConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  bridgeUrl: z.string().regex(/^https?:\/\//, "bridgeUrl must start with http:// or https://").default("http://127.0.0.1:9876/v1"),
-  defaultModel: z.enum(BROWSER_PILOT_MODELS).default("claude-3.5-sonnet"),
-  defaultCdpUrl: z.string().min(1).optional(),
-  allowedDomains: z.array(z.string().min(1)).default([]),
-  forbiddenCdpMethods: z.array(z.string().min(1)).default(["Browser.close"]),
-  maxStepsDefault: z.number().int().min(1).max(100).default(25),
-  tokenBudgetPerDay: z.number().int().nonnegative().optional()
-}).default({
-  enabled: false,
-  bridgeUrl: "http://127.0.0.1:9876/v1",
-  defaultModel: "claude-3.5-sonnet",
-  allowedDomains: [],
-  forbiddenCdpMethods: ["Browser.close"],
-  maxStepsDefault: 25
-});
-var FlowConfigSchema = z.object({
-  /** Master switch. OFF = byte-identical legacy context behaviour. */
-  enabled: z.boolean().default(false),
-  /** λ_base — minimum architectural forgetting rate. */
-  lambdaBase: z.number().min(0).default(0.15),
-  /** α — hypofrontality accelerator (weight of Φ on λ_flow). */
-  alpha: z.number().min(0).default(1.5),
-  /** BFS depth used to pull distant pinned invariants back into scope. */
-  maxDepth: z.number().int().min(0).max(6).default(3),
-  /** Peripheral neighbours below this decayed weight are pruned (unless pinned). */
-  weightThreshold: z.number().min(0).max(1).default(0.1),
-  /** EMA gain per consecutive success when computing Φ. */
-  emaGain: z.number().min(0).max(1).default(0.34),
-  /** Multiplier applied to Φ on a failure (0 = hard reset → re-hydrate memory). */
-  resetFactor: z.number().min(0).max(1).default(0),
-  /** Damping fraction of `emaGain` applied on a `partial` outcome. */
-  partialFactor: z.number().min(0).max(1).default(0.5),
-  /** rag budget is never scaled below this fraction of baseline (long-range safety). */
-  budgetFloorRatio: z.number().min(0).max(1).default(0.25),
-  /** How many recent task outcomes feed Φ. */
-  historyWindow: z.number().int().min(1).max(200).default(12),
-  /** Node types that are never diluted. */
-  pinnedTypes: z.array(z.string()).default(["constraint", "risk", "decision", "acceptance_criteria", "constitution", "requirement"]),
-  /** A/B experiment: alternate flow_on/flow_off deterministically per node to measure impact. */
-  experiment: z.object({ abEnabled: z.boolean().default(false) }).default({ abEnabled: false })
-});
-var ConfigSchema = z.object({
-  port: z.number().int().min(1).max(65535).default(3e3),
-  dbPath: z.string().default("workflow-graph"),
-  basePath: z.string().optional(),
-  contextMode: ContextModeSchema.default("lean"),
-  profile: ProfileFilterConfigSchema.default("all"),
-  dashboard: z.object({
-    autoOpen: z.boolean().default(true)
-  }).default({ autoOpen: true }),
-  integrations: z.object({
-    codeGraphAutoIndex: z.boolean().default(true),
-    codeGraphReindexIntervalSec: z.number().int().min(0).default(0),
-    lspServers: z.array(LspConfigOverrideSchema).default([]),
-    browserAutomation: BrowserAutomationConfigSchema
-  }).prefault({}),
-  flow: FlowConfigSchema.prefault({})
-});
-
-// src/core/config/config-loader.ts
+init_config_schema();
 init_errors();
 init_logger();
-var log35 = createLogger({ layer: "core", source: "config-loader.ts" });
+var log38 = createLogger({ layer: "core", source: "config-loader.ts" });
 var CONFIG_FILENAME = "mcp-graph.config.json";
 function loadConfig(basePath) {
   const resolvedBase = basePath ?? process.cwd();
@@ -11901,13 +12864,13 @@ function loadConfig(basePath) {
     try {
       const raw = readFileSync(configPath, "utf-8").replace(/^\uFEFF/, "");
       fileConfig = JSON.parse(raw);
-      log35.info(`Config loaded from ${configPath}`);
+      log38.info(`Config loaded from ${configPath}`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new McpGraphError(`Invalid config at ${configPath}: ${msg}`);
     }
   } else {
-    log35.info("No config file found, using defaults");
+    log38.info("No config file found, using defaults");
   }
   if (process.env.MCP_PORT) {
     const envPort = parseInt(process.env.MCP_PORT, 10);
@@ -11927,7 +12890,7 @@ function loadConfig(basePath) {
 // src/core/config/ignore-templates.ts
 init_esm_shims();
 init_logger();
-var log36 = createLogger({ layer: "core", source: "ignore-templates.ts" });
+var log39 = createLogger({ layer: "core", source: "ignore-templates.ts" });
 var IGNORE_TEMPLATE = `# ========================================
 # LEAN CONTEXT (mcp-graph)
 # Filosofia: zero auto-load, tudo on-demand via MCP
@@ -12078,21 +13041,21 @@ release-please-config.json
 function ensureClaudeIgnore(projectDir) {
   const filePath = path17__default.join(projectDir, ".claudeignore");
   if (existsSync(filePath)) {
-    log36.debug(".claudeignore already exists, skipping");
+    log39.debug(".claudeignore already exists, skipping");
     return false;
   }
   writeFileSync(filePath, IGNORE_TEMPLATE, "utf-8");
-  log36.info(".claudeignore created with lean context template");
+  log39.info(".claudeignore created with lean context template");
   return true;
 }
 function ensureCopilotIgnore(projectDir) {
   const filePath = path17__default.join(projectDir, ".copilotignore");
   if (existsSync(filePath)) {
-    log36.debug(".copilotignore already exists, skipping");
+    log39.debug(".copilotignore already exists, skipping");
     return false;
   }
   writeFileSync(filePath, IGNORE_TEMPLATE, "utf-8");
-  log36.info(".copilotignore created with lean context template");
+  log39.info(".copilotignore created with lean context template");
   return true;
 }
 function updateIgnoreFile(filePath, label, dryRun) {
@@ -12100,7 +13063,7 @@ function updateIgnoreFile(filePath, label, dryRun) {
   if (!exists) {
     if (!dryRun) {
       writeFileSync(filePath, IGNORE_TEMPLATE, "utf-8");
-      log36.info(`${label} created with lean context template`);
+      log39.info(`${label} created with lean context template`);
     }
     return { status: "created", message: `${label} created` };
   }
@@ -12110,7 +13073,7 @@ function updateIgnoreFile(filePath, label, dryRun) {
   }
   if (!dryRun) {
     writeFileSync(filePath, IGNORE_TEMPLATE, "utf-8");
-    log36.info(`${label} updated to latest template`);
+    log39.info(`${label} updated to latest template`);
   }
   return { status: "updated", message: `${label} updated` };
 }
@@ -12787,7 +13750,7 @@ init_registry();
 // src/core/atomic-files/writer-markdown.ts
 init_esm_shims();
 init_logger();
-var log37 = createLogger({ layer: "core", source: "writer-markdown.ts" });
+var log40 = createLogger({ layer: "core", source: "writer-markdown.ts" });
 var markerStart2 = (id) => `<!-- MCP-GRAPH:MANAGED-START:${id} -->`;
 var markerEnd2 = (id) => `<!-- MCP-GRAPH:MANAGED-END:${id} -->`;
 function extractManagedBlock(content, fileId) {
@@ -12849,7 +13812,7 @@ async function write(file, mode) {
     const existingBlock = extractManagedBlock(current, fileId);
     const tampered = existingBlock !== null && detectTampering(filePath, fileId, existingBlock);
     if (tampered) {
-      log37.warn("managed block tampered \u2014 system reconquering", { fileId, filePath });
+      log40.warn("managed block tampered \u2014 system reconquering", { fileId, filePath });
       fs.writeFileSync(filePath + ".user-modified.bak", current, "utf8");
     }
     if (!tampered && existingBlock === managedContent) {
@@ -12887,7 +13850,7 @@ async function atomicWrite(filePath, content) {
     try {
       fs.unlinkSync(tmp);
     } catch (e) {
-      log37.debug("intentional swallow", { error: e, reason: "tmp file already gone, cleanup not needed" });
+      log40.debug("intentional swallow", { error: e, reason: "tmp file already gone, cleanup not needed" });
     }
     throw err;
   }
@@ -12915,7 +13878,7 @@ async function runAtomicWrites(mode) {
 }
 
 // src/cli/commands/init-cmd.ts
-var log38 = createLogger({ layer: "cli", source: "init.ts" });
+var log41 = createLogger({ layer: "cli", source: "init.ts" });
 var LEVEL_ICON = { ok: "\u2713", warning: "\u26A0", error: "\u2717" };
 async function runInitOrchestration(opts, deps) {
   const { dir, skipNeural, noServe, port } = opts;
@@ -13028,7 +13991,7 @@ function initCommand() {
     const dir = path17__default.resolve(opts.dir);
     const port = parseInt(opts.port, 10);
     if (isNaN(port) || port < 1 || port > 65535) {
-      log38.error("Invalid port number", { port: opts.port });
+      log41.error("Invalid port number", { port: opts.port });
       process.exitCode = 1;
       return;
     }
@@ -13046,7 +14009,7 @@ function initCommand() {
         out("\nPronto. Execute `mcp-graph serve` para iniciar o servidor.");
       }
     } catch (error) {
-      log38.error("Init failed", { error: getErrorMessage(error) });
+      log41.error("Init failed", { error: getErrorMessage(error) });
       process.exitCode = 1;
     }
   });
@@ -13111,7 +14074,7 @@ function readDaemonMeta(stateDir) {
 
 // src/core/daemon/daemon-reaper.ts
 init_logger();
-var log40 = createLogger({ layer: "core", source: "daemon-reaper" });
+var log43 = createLogger({ layer: "core", source: "daemon-reaper" });
 function defaultDaemonRoot(home = os.homedir()) {
   return path17__default.join(home, ".mcp-graph");
 }
@@ -13150,7 +14113,7 @@ function reapDaemons(options = {}) {
           try {
             kill(lock.pid);
           } catch (err) {
-            log40.debug("intentional-swallow", {
+            log43.debug("intentional-swallow", {
               error: String(err),
               reason: "process vanished between liveness probe and signal \u2014 treat as already reaped"
             });
@@ -13180,7 +14143,7 @@ function reapDaemons(options = {}) {
       try {
         fs__default.rmSync(stateDir, { recursive: true, force: true });
       } catch (err) {
-        log40.debug("intentional-swallow", {
+        log43.debug("intentional-swallow", {
           error: String(err),
           reason: "state dir removal hit a permission error or race \u2014 next reaper run retries"
         });
@@ -13200,14 +14163,14 @@ function reapDaemons(options = {}) {
 
 // src/cli/commands/daemon-cmd.ts
 init_logger();
-var log41 = createLogger({ layer: "cli", source: "daemon.ts" });
+var log44 = createLogger({ layer: "cli", source: "daemon.ts" });
 function output12(msg) {
   process.stdout.write(msg + "\n");
 }
 function daemonCommand() {
   const cmd = new Command("daemon").description("Inspect and clean up mcp-graph daemons");
   cmd.command("prune").description("Kill orphaned daemons (workspace gone) and remove stale state dirs").option("--dry-run", "Show what would be reaped without killing or deleting", false).action((opts) => {
-    log41.info("cli:daemon:prune", { dryRun: opts.dryRun });
+    log44.info("cli:daemon:prune", { dryRun: opts.dryRun });
     const report = reapDaemons({ dryRun: opts.dryRun });
     const prefix = opts.dryRun ? "[dry-run] " : "";
     for (const a of report.actions) {
@@ -13279,7 +14242,7 @@ function formatProviderReport(report) {
 // src/cli/commands/doctor-cmd.ts
 init_errors();
 init_logger();
-var log42 = createLogger({ layer: "cli", source: "doctor.ts" });
+var log45 = createLogger({ layer: "cli", source: "doctor.ts" });
 function output13(msg) {
   process.stdout.write(msg + "\n");
 }
@@ -13334,7 +14297,7 @@ function doctorCommand() {
         process.exit(1);
       }
     } catch (err) {
-      log42.error(`Doctor failed: ${getErrorMessage(err)}`);
+      log45.error(`Doctor failed: ${getErrorMessage(err)}`);
       process.exit(1);
     }
   });
@@ -13346,7 +14309,7 @@ init_esm_shims();
 // src/core/autonomy/shadow-branch.ts
 init_esm_shims();
 init_logger();
-var log43 = createLogger({ layer: "core", source: "shadow-branch.ts" });
+var log46 = createLogger({ layer: "core", source: "shadow-branch.ts" });
 function parseShadowTimestamp(branchName) {
   const match = /-(\d{10,})$/.exec(branchName);
   if (!match) return null;
@@ -13388,7 +14351,7 @@ function pruneOrphanWorktrees(options) {
     ).toString();
     branches = out2.split("\n").map((s) => s.trim()).filter(Boolean);
   } catch (err) {
-    log43.debug("shadow-branch:prune:list-failed", { error: String(err) });
+    log46.debug("shadow-branch:prune:list-failed", { error: String(err) });
   }
   const wtMap = branches.length > 0 ? listShadowWorktrees(execOpts) : /* @__PURE__ */ new Map();
   for (const branch of branches) {
@@ -13400,34 +14363,34 @@ function pruneOrphanWorktrees(options) {
         execSync(`git worktree remove --force --force ${wtPath}`, execOpts);
         reapedWorktrees += 1;
       } catch (err) {
-        log43.debug("shadow-branch:prune:wt-remove-failed", { branch, wtPath, error: String(err) });
+        log46.debug("shadow-branch:prune:wt-remove-failed", { branch, wtPath, error: String(err) });
       }
     }
     try {
       execSync(`git branch -D ${branch}`, execOpts);
       reapedBranches += 1;
     } catch (err) {
-      log43.debug("shadow-branch:prune:branch-delete-failed", { branch, error: String(err) });
+      log46.debug("shadow-branch:prune:branch-delete-failed", { branch, error: String(err) });
     }
   }
   try {
-    const output15 = execSync("git worktree prune --verbose", execOpts).toString();
+    const output16 = execSync("git worktree prune --verbose", execOpts).toString();
     if (reapedBranches > 0 || reapedWorktrees > 0) {
-      log43.info("shadow-branch:prune-ok", { reapedBranches, reapedWorktrees, ttlMs });
+      log46.info("shadow-branch:prune-ok", { reapedBranches, reapedWorktrees, ttlMs });
     } else {
-      log43.debug("shadow-branch:prune-ok", { reapedBranches, reapedWorktrees, output: output15 });
+      log46.debug("shadow-branch:prune-ok", { reapedBranches, reapedWorktrees, output: output16 });
     }
-    return { pruned: true, reapedBranches, reapedWorktrees, output: output15 };
+    return { pruned: true, reapedBranches, reapedWorktrees, output: output16 };
   } catch (err) {
     const error = String(err);
-    log43.debug("shadow-branch:prune-failed", { error });
+    log46.debug("shadow-branch:prune-failed", { error });
     return { pruned: false, reapedBranches, reapedWorktrees, error };
   }
 }
 
 // src/cli/commands/gc-cmd.ts
 init_logger();
-var log44 = createLogger({ layer: "cli", source: "gc.ts" });
+var log47 = createLogger({ layer: "cli", source: "gc.ts" });
 function output14(msg) {
   process.stdout.write(msg + "\n");
 }
@@ -13435,7 +14398,7 @@ function gcCommand() {
   return new Command("gc").description("Garbage-collect orphan ai-shadow/* worktrees and branches").option("-d, --dir <dir>", "Project directory (git root)", process.cwd()).option("--ttl <minutes>", "Only reap branches older than N minutes (0 = all)", "0").action((opts) => {
     const ttlMinutes = parseInt(opts.ttl, 10);
     const ttlMs = Number.isFinite(ttlMinutes) && ttlMinutes > 0 ? ttlMinutes * 60 * 1e3 : 0;
-    log44.info("cli:gc:start", { dir: opts.dir, ttlMs });
+    log47.info("cli:gc:start", { dir: opts.dir, ttlMs });
     const result = pruneOrphanWorktrees({ cwd: opts.dir, ttlMs });
     if (result.pruned) {
       output14(`gc: reaped ${result.reapedBranches} branches, ${result.reapedWorktrees} worktrees`);
@@ -13446,6 +14409,48 @@ function gcCommand() {
   });
 }
 
+// src/cli/commands/skill-cmd.ts
+init_esm_shims();
+init_skill_registry();
+function output15(msg) {
+  process.stdout.write(msg + "\n");
+}
+function skillCommand() {
+  const cmd = new Command("skill").description("Lista e exibe skills (instru\xE7\xF5es para agentes)");
+  cmd.command("list").description("Lista as skills dispon\xEDveis (src/skills, .agents/skills, .claude/skills)").option("-p, --phase <fase>", "Ordena/filtra pela fase do ciclo (ANALYZE, IMPLEMENT, \u2026)").option("-d, --dir <dir>", "Raiz do projeto", process.cwd()).action((opts) => {
+    const seen = /* @__PURE__ */ new Set();
+    let count = 0;
+    for (const root of defaultSkillRoots(opts.dir)) {
+      const { skills } = listSkills(root, opts.phase);
+      for (const s of skills) {
+        if (seen.has(s.name)) continue;
+        seen.add(s.name);
+        count += 1;
+        output15(`${s.name.padEnd(28)} [${s.category}] ${s.description}`);
+      }
+    }
+    if (count === 0) output15("Nenhuma skill encontrada.");
+    else output15(`
+${count} skill(s).`);
+  });
+  cmd.command("show <nome>").description("Imprime as instru\xE7\xF5es completas de uma skill").option("-d, --dir <dir>", "Raiz do projeto", process.cwd()).action((nome, opts) => {
+    for (const root of defaultSkillRoots(opts.dir)) {
+      const found = invokeSkill(root, nome);
+      if (found) {
+        output15(`=== ${found.name} ===`);
+        output15(`[${found.category}] ${found.description}`);
+        if (found.phases.length > 0) output15(`fases: ${found.phases.join(", ")}`);
+        output15("");
+        output15(found.body);
+        return;
+      }
+    }
+    output15(`Skill n\xE3o encontrada: ${nome}. Tente 'skill list'.`);
+    process.exitCode = 1;
+  });
+  return cmd;
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("agent-graph-flow").description(PROMISE).version(VERSION, "-v, --version");
@@ -13466,6 +14471,7 @@ program.addCommand(initCommand());
 program.addCommand(daemonCommand());
 program.addCommand(doctorCommand());
 program.addCommand(gcCommand());
+program.addCommand(skillCommand());
 function shouldLaunchTui() {
   const noArgs = process.argv.length <= 2;
   const isTty = Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);