@orkastery/cli 0.2.0 → 0.4.1

package/dist/memory-migration.js

@@ -0,0 +1,279 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repositorioAlvoDeclarado = repositorioAlvoDeclarado;
+exports.inventariarHandoffs = inventariarHandoffs;
+exports.verificarHandoffMigrado = verificarHandoffMigrado;
+exports.migrarHandoffs = migrarHandoffs;
+/** Migracao aditiva de fontes canonicas. Nenhum arquivo ou registro antigo e removido. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
+const estado_thread_1 = require("./estado-thread");
+const thread_1 = require("./thread");
+const ledger_1 = require("./ledger");
+const escopo_escrita_1 = require("./escopo-escrita");
+const memoria_1 = require("./memoria");
+const orkmind_1 = require("./orkmind");
+const hash = (bytes) => (0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex');
+function arquivos(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    if (fs.lstatSync(dir).isSymbolicLink())
+        throw new Error('memory.inventory.special-file');
+    return fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name)).flatMap(e => {
+        if (e.isSymbolicLink() || (!e.isFile() && !e.isDirectory()))
+            throw new Error('memory.inventory.special-file');
+        const nome = path.join(dir, e.name);
+        return e.isDirectory() ? arquivos(nome) : [nome];
+    });
+}
+/**
+ * O repositorio alvo que um handoff em Markdown declara na linha `Repo alvo: <caminho>`.
+ *
+ * So a declaracao explicita conta: o nome solto no texto nunca classifica tenant. O tenant e o
+ * ultimo segmento do caminho, normalizado (`/srv/projetos/Outro-Board` vira `outro-board`).
+ */
+function repositorioAlvoDeclarado(texto) {
+    const linha = /^\s*Repo alvo:\s*`?([^`\n]+?)`?\s*\.?\s*$/mi.exec(texto);
+    const nome = linha?.[1].replace(/[\\/]+$/, '').split(/[\\/]/).pop()?.trim();
+    if (!nome)
+        return null;
+    const tenant = nome.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+    return tenant ? { nome, tenant } : null;
+}
+/**
+ * Inclui o snapshot atual e todo o historico das threads EXPLICITAMENTE autorizadas, e so isso.
+ * D23: a caixa compartilhada `.orkastery/handoffs` e as threads fora da allowlist nao sao
+ * consultadas, enumeradas, lidas nem hasheadas em nenhum ponto -- a allowlist limita a LEITURA,
+ * nao apenas a selecao. Por isso `incluidos`/`excluidos` contam somente fontes autorizadas
+ * efetivamente inspecionadas: a ausencia de uma fonte fora do escopo neste resultado nao afirma
+ * que ela nao existe nem classifica o tenant dela.
+ */
+function inventariarHandoffs(carregado, escopo) {
+    const autorizadas = (0, escopo_escrita_1.exigirEscopoDeEscrita)(escopo);
+    const raiz = (0, estado_thread_1.raizDoEstado)(carregado.raiz), estado = path.join(raiz, '.orkastery');
+    const tenant = carregado.manifesto.memory.tenant || carregado.manifesto.project.name;
+    const candidatos = new Map();
+    const threads = path.join(estado, 'threads');
+    for (const id of autorizadas) {
+        (0, escopo_escrita_1.validarDiretorioDeThread)(carregado.raiz, id);
+        const dir = path.join(threads, id), atual = path.join(dir, 'handoff.json');
+        if (!fs.existsSync(dir) || fs.lstatSync(dir).isSymbolicLink())
+            throw new Error('memory.inventory.thread-invalid');
+        if (fs.existsSync(atual))
+            candidatos.set(atual, id);
+        for (const nome of arquivos(path.join(dir, 'handoffs')))
+            candidatos.set(nome, id);
+    }
+    const fontes = [...candidatos].sort(([a], [b]) => a.localeCompare(b)).map(([absoluto, dono]) => {
+        // Invariante da allowlist: nenhum candidato nasce fora dela, porque nada fora dela e percorrido.
+        if (!autorizadas.has(dono))
+            throw new Error('scope.thread.unauthorized');
+        if (fs.lstatSync(absoluto).isSymbolicLink())
+            throw new Error('memory.inventory.special-file');
+        const bytes = fs.readFileSync(absoluto), texto = bytes.toString('utf8');
+        const formato = path.extname(absoluto).slice(1).toLowerCase();
+        const fonte = { arquivo: path.relative(raiz, absoluto).split(path.sep).join('/'),
+            sha256: hash(bytes), bytes: bytes.length, formato, tenant: null, thread: dono,
+            origem: null, destino: null, incluir: false, motivo: 'origem_nao_confirmada', bloqueante: false };
+        // Declaracao explicita do repositorio alvo de OUTRO projeto, nao uma ocorrencia casual do nome.
+        const alvo = formato === 'md' ? repositorioAlvoDeclarado(texto) : null;
+        if (alvo && alvo.tenant !== tenant) {
+            return { ...fonte, tenant: alvo.tenant, origem: `${alvo.nome} (declarado na fonte)`,
+                destino: alvo.nome, motivo: 'tenant_externo_reservado' };
+        }
+        let h;
+        if (formato === 'json') {
+            try {
+                h = JSON.parse(texto);
+            }
+            catch {
+                fonte.motivo = 'json_invalido';
+            }
+        }
+        // A propriedade vem do diretorio autorizado que continha o arquivo; `h.thread` declarado
+        // dentro do proprio JSON nunca autoriza nada, so e conferido contra o dono real mais abaixo.
+        const id = dono;
+        if (!fs.existsSync(path.join(threads, id, 'thread.json')))
+            return fonte;
+        const thread = (0, thread_1.lerThread)(carregado.raiz, id);
+        fonte.thread = id;
+        fonte.tenant = thread.projeto.name === carregado.manifesto.project.name ? tenant : thread.projeto.name;
+        if (fonte.tenant !== tenant)
+            return { ...fonte, motivo: 'tenant_externo_reservado' };
+        if (formato !== 'json')
+            return { ...fonte, motivo: 'formato_sem_contrato' };
+        if (!h || h.thread !== id || h.versao !== 1 || !h.de?.slug || !h.para?.slug ||
+            !Array.isArray(h.inline) || !Array.isArray(h.pointers) || !Array.isArray(h.summaries)) {
+            return { ...fonte, motivo: 'handoff_invalido', bloqueante: true };
+        }
+        return { ...fonte, origem: `${h.de.slug}:${h.de.fase ?? 'desconhecida'}`,
+            destino: `${h.para.slug}:${h.para.fase ?? 'desconhecida'}`, incluir: true, motivo: 'tenant_confirmado' };
+    });
+    return { tenant, fontes, incluidos: fontes.filter(f => f.incluir).length, excluidos: fontes.filter(f => !f.incluir).length };
+}
+function lerFonte(carregado, fonte) {
+    const raiz = (0, estado_thread_1.raizDoEstado)(carregado.raiz), absoluto = path.resolve(raiz, fonte.arquivo);
+    if (!absoluto.startsWith(path.join(raiz, '.orkastery') + path.sep) ||
+        !fs.realpathSync(absoluto).startsWith(fs.realpathSync(path.join(raiz, '.orkastery')) + path.sep)) {
+        throw new Error('memory.migration.source-outside-state');
+    }
+    const bytes = fs.readFileSync(absoluto);
+    if (hash(bytes) !== fonte.sha256 || bytes.length !== fonte.bytes)
+        throw new Error('memory.migration.source-changed');
+    const texto = bytes.toString('utf8');
+    if (!Buffer.from(texto).equals(bytes))
+        throw new Error('memory.migration.invalid-utf8');
+    return texto;
+}
+/** Readback de manutencao pela biblioteca instalada. Nao altera filtros do recall. */
+function verificarHandoffMigrado(driver, p, r) {
+    if (!r.ok || !r.readback || !r.id || !r.session_entry_id || !r.package_entry_id || !r.package_id || !driver.recuperar) {
+        throw new Error('memory.migration.readback-missing');
+    }
+    const session = driver.recuperar('session', r.session_entry_id);
+    const handoff = driver.recuperar('handoff', r.id);
+    const pacote = driver.recuperar('semantic_log', r.package_entry_id);
+    if (!session || !handoff || !pacote || handoff.parent_id !== session.id || pacote.parent_id !== session.id ||
+        session.metadata.session_id !== p.sessionId || handoff.metadata.package_id !== r.package_id ||
+        pacote.metadata.package_id !== r.package_id || handoff.metadata.package_entry_id !== pacote.id ||
+        !(0, node_util_1.isDeepStrictEqual)(JSON.parse(pacote.content), p.payload))
+        throw new Error('memory.migration.readback-mismatch');
+    for (const entry of [session, handoff, pacote]) {
+        if (entry.source !== 'agent' || entry.mandatory || entry.priority === 'critical' ||
+            !Object.entries(p.tags).every(([k, values]) => values.every(v => entry.tags[k]?.includes(v)))) {
+            throw new Error('memory.migration.readback-tags');
+        }
+    }
+    for (const entry of [handoff, pacote])
+        for (const [k, value] of Object.entries(p.metadata)) {
+            if (!(0, node_util_1.isDeepStrictEqual)(entry.metadata[k], value))
+                throw new Error('memory.migration.readback-provenance');
+        }
+    if (handoff.metadata.orkastery_identity !== p.identidade || pacote.metadata.orkastery_identity !== p.identidade) {
+        throw new Error('memory.migration.readback-identity');
+    }
+    return { session: session.id, handoff: handoff.id, semantic_log: pacote.id, parent_id: session.id,
+        package_id: r.package_id, sha256: p.metadata.sha256, tags: p.tags, originalIntegral: true };
+}
+function migrarHandoffs(carregado, opcoes) {
+    const operacaoId = opcoes.operacaoId ?? (0, node_crypto_1.randomUUID)();
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(operacaoId))
+        throw new Error('memory.migration.operation-invalid');
+    const autorizadas = (0, escopo_escrita_1.exigirEscopoDeEscrita)(opcoes?.escopo);
+    if (!autorizadas.has(opcoes.operadora))
+        throw new Error('scope.thread.unauthorized');
+    (0, escopo_escrita_1.validarDiretorioDeThread)(carregado.raiz, opcoes.operadora);
+    const operadora = (0, thread_1.lerThread)(carregado.raiz, opcoes.operadora);
+    if (operadora.projeto.name !== carregado.manifesto.project.name)
+        throw new Error('memory.tenant.mismatch');
+    const auditoria = (0, thread_1.dirThread)(carregado.raiz, operadora.id);
+    const atual = inventariarHandoffs(carregado, opcoes.escopo), inventario = opcoes.inventario ?? atual;
+    if (!(0, node_util_1.isDeepStrictEqual)(inventario.fontes.map(f => [f.arquivo, f.thread, f.incluir, f.tenant]), atual.fontes.map(f => [f.arquivo, f.thread, f.incluir, f.tenant]))) {
+        throw new Error('memory.migration.incomplete-inventory');
+    }
+    const tenant = carregado.manifesto.memory.tenant || carregado.manifesto.project.name;
+    if (inventario.tenant !== tenant || inventario.fontes.some(f => f.incluir && f.tenant !== tenant))
+        throw new Error('memory.tenant.mismatch');
+    if (inventario.fontes.some(f => f.bloqueante))
+        throw new Error('memory.migration.invalid-inventory');
+    // Preflight de todas as fontes antes da primeira escrita. Snapshot nao autoriza outro tenant.
+    const pedidos = inventario.fontes.filter(f => f.incluir).map(fonte => {
+        if (!fonte.thread || !autorizadas.has(fonte.thread))
+            throw new Error('scope.thread.unauthorized');
+        const texto = lerFonte(carregado, fonte), thread = (0, thread_1.lerThread)(carregado.raiz, fonte.thread);
+        return { fonte, pedido: (0, memoria_1.prepararHandoffGovernado)(carregado.manifesto, thread, JSON.parse(texto), fonte.arquivo, texto, carregado.raiz) };
+    });
+    const operacaoHash = hash(JSON.stringify({ tenant, operadora: operadora.id, escopo: [...autorizadas].sort(),
+        fontes: pedidos.map(({ fonte, pedido }) => [fonte.arquivo, fonte.sha256, pedido.identidade]) }));
+    const eventos = (0, ledger_1.lerLedger)(auditoria);
+    const recibos = eventos.filter(e => ['memory_migrated', 'memory_migration_failed', 'memory_migration_attempt'].includes(e.tipo));
+    if (recibos.some(e => e.operacaoId === operacaoId && e.operacaoHash !== operacaoHash)) {
+        throw new Error('memory.migration.operation-conflict');
+    }
+    const publicados = new Set(recibos.filter(e => e.tipo === 'memory_migrated').map(e => e.identidade));
+    const anteriores = new Map(recibos.filter(e => e.operacaoId === operacaoId).map(e => [e.identidade, e]));
+    const driver = opcoes.driver ?? (0, orkmind_1.resolverRegime)(carregado.manifesto, null).driver;
+    if (!driver?.contagens || !driver.recuperar || !driver.submeterHandoff)
+        throw new Error('memory.migration.unavailable');
+    const memoria = (0, memoria_1.abrirMemoria)(carregado, { driver });
+    if (!memoria.ativo)
+        throw new Error('memory.migration.unavailable');
+    const antes = driver.contagens(); // Erro de leitura reprova; nunca assume base vazia.
+    const resultados = pedidos.map(({ fonte, pedido }) => {
+        const anterior = anteriores.get(pedido.identidade);
+        if (anterior) {
+            return { arquivo: fonte.arquivo, sha256: fonte.sha256, identidade: pedido.identidade,
+                ok: anterior.tipo !== 'memory_migration_failed', replay: true,
+                gravacao: anterior.gravacao,
+                readback: anterior.readback,
+                erro: anterior.tipo === 'memory_migration_failed' ? String(anterior.erro) : null };
+        }
+        try {
+            if (!fonte.thread || !autorizadas.has(fonte.thread))
+                throw new Error('scope.thread.unauthorized');
+            (0, escopo_escrita_1.validarDiretorioDeThread)(carregado.raiz, fonte.thread);
+            (0, escopo_escrita_1.validarDiretorioDeThread)(carregado.raiz, operadora.id);
+            lerFonte(carregado, fonte);
+            const gravacao = memoria.submeterHandoff(pedido);
+            const readback = verificarHandoffMigrado(driver, pedido, gravacao);
+            lerFonte(carregado, fonte);
+            const r = { arquivo: fonte.arquivo, sha256: fonte.sha256, identidade: pedido.identidade, ok: true,
+                gravacao, readback, erro: null, replay: false };
+            const evento = (0, ledger_1.registrar)(auditoria, operadora.id, publicados.has(pedido.identidade) ? 'memory_migration_attempt' : 'memory_migrated', { tenant, fonteThread: fonte.thread, operacaoId, operacaoHash, ...r });
+            anteriores.set(pedido.identidade, evento);
+            publicados.add(pedido.identidade);
+            return r;
+        }
+        catch (e) {
+            // Nunca propaga texto arbitrario da fonte ou do subprocesso ao CLI/ledger.
+            const codigo = e instanceof Error && /^memory\.(migration\.[a-z-]+|tenant\.mismatch)$/.test(e.message) ? e.message : 'memory.migration.failed';
+            const r = { arquivo: fonte.arquivo, sha256: fonte.sha256, identidade: pedido.identidade, ok: false,
+                gravacao: null, readback: null, erro: codigo, replay: false };
+            const evento = (0, ledger_1.registrar)(auditoria, operadora.id, 'memory_migration_failed', { tenant, fonteThread: fonte.thread, operacaoId, operacaoHash, ...r });
+            anteriores.set(pedido.identidade, evento);
+            return r;
+        }
+    });
+    const depois = driver.contagens();
+    if (Object.entries(antes).some(([c, n]) => (depois[c] ?? 0) < n))
+        throw new Error('memory.migration.count-decreased');
+    const falhas = resultados.filter(r => !r.ok).length;
+    return { ok: falhas === 0, operacaoId, inventario, antes, depois, resultados, falhas,
+        replay: resultados.length > 0 && resultados.every(r => r.replay),
+        contrato: 'mesmo ID recupera terminais e retoma somente sem recibo; falha exige novo ID para nova tentativa' };
+}

package/dist/memory-prospective.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAMPOS_NATIVOS = exports.hashProspectivo = void 0;
+exports.prepararVersaoProspectiva = prepararVersaoProspectiva;
+/** Preparacao prospectiva exclusivamente offline; dados privados entram por recibo restrito. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const manifest_1 = require("./manifest");
+const escopo_escrita_1 = require("./escopo-escrita");
+const memoria_1 = require("./memoria");
+const orkmind_1 = require("./orkmind");
+const hashProspectivo = (s) => (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
+exports.hashProspectivo = hashProspectivo;
+exports.CAMPOS_NATIVOS = (0, orkmind_1.camposNativos)();
+function prepararVersaoProspectiva(carregado, recibo, autoria) {
+    const m = carregado.manifesto;
+    const tenant = m.memory.tenant || m.project.name;
+    if (recibo.tenant !== (autoria.tenantNativo ?? tenant))
+        throw new Error('memory.tenant.mismatch');
+    if (!/^[a-f0-9]{64}$/.test(autoria.reciboSha256) || !/^[a-f0-9]{40}$/.test(autoria.revisao) ||
+        !(0, orkmind_1.agenteProspectivoValido)(autoria.agente))
+        throw new Error('memory.prospective.authorship');
+    if (recibo.ids.length !== 3 || new Set(recibo.ids).size !== 3 || recibo.entries.length !== 3 ||
+        new Set(recibo.entries.map(e => e.id)).size !== 3 || recibo.entries.some(e => !recibo.ids.includes(e.id)) ||
+        recibo.ids.some(id => !/^[a-f0-9-]{36}$/.test(id)))
+        throw new Error('memory.prospective.scope');
+    const driver = new orkmind_1.DriverEmMemoria();
+    const local = { ...carregado, manifesto: { ...m, memory: { ...m.memory, mode: 'orkmind' } } };
+    const publicacao = (0, memoria_1.gravarPolicies)((0, memoria_1.abrirMemoria)(local, { driver }), m);
+    if (publicacao.falhas || driver.tudo().length !== 3)
+        throw new Error('memory.prospective.manifest-changed');
+    const hashes = new Set();
+    const entradas = [...recibo.entries].sort((a, b) => a.id.localeCompare(b.id)).map(old => {
+        if (exports.CAMPOS_NATIVOS.some(k => !(k in old)))
+            throw new Error('memory.prospective.snapshot-incomplete');
+        const atual = driver.tudo().find(e => (0, exports.hashProspectivo)(e.content) === old.content_hash);
+        if (!atual || (0, exports.hashProspectivo)(old.content) !== old.content_hash || hashes.has(old.content_hash))
+            throw new Error('memory.prospective.hash-mismatch');
+        hashes.add(old.content_hash);
+        if (old.collection !== 'rule' || old.source !== 'agent' || old.priority !== 'high' || old.mandatory !== false ||
+            old.protected !== false || old.version !== 1 || old.author_id !== null || old.visibility !== 'private' ||
+            old.scope !== 'project' || Object.keys(old.metadata).length || (old.tags.editors ?? []).length ||
+            old.tags.project?.length !== 1 || old.tags.project[0] !== tenant)
+            throw new Error('memory.prospective.legacy-changed');
+        const tags = Object.fromEntries([...new Set([...Object.keys(old.tags), ...Object.keys(atual.tags)])].map(k => [k, [...new Set([...(old.tags[k] ?? []), ...(atual.tags[k] ?? [])])].sort()]));
+        const originalJson = JSON.stringify(old);
+        const marcador = { schema: 'ork.prospective-origin/v1', historicalOrigin: 'unknown', source: 'agent',
+            agent: autoria.agente, revision: autoria.revisao, receiptSha256: autoria.reciboSha256,
+            entryId: old.id, originalJson, originalSha256: (0, exports.hashProspectivo)(originalJson) };
+        const proposta = { ...structuredClone(old), tags,
+            metadata: { ...structuredClone(atual.metadata), orkastery_prospective: marcador } };
+        return { id: old.id, sha256: old.content_hash, origemHistorica: 'desconhecida', antes: structuredClone(old), proposta };
+    });
+    return { versao: 2, tipo: 'memory.prospective.preparation', executavel: false, aplicacaoDisponivel: false,
+        impedimento: 'memory.legacy.provenance-collision', liberaShip: false, novaObservacaoOperacional: false,
+        motivo: 'memory.prospective.preconditions-missing', entradas, autoriaProspectiva: { ...autoria, source: 'agent' },
+        faltantes: ['autoridade nativa identificada para as entradas privadas orfas; nao omitir requester apos recusa',
+            'recibo transacional e arquivo integral duravel; locks e compare integral na mesma transacao',
+            'rollback compensatorio testado e CHECK independente no HEAD da operacao',
+            'decisao tipada do condutor antes de qualquer aplicacao'],
+    };
+}
+if (require.main === module) {
+    try {
+        const args = process.argv.slice(2);
+        const value = (key) => args[args.indexOf(key) + 1];
+        const flags = ['--recibo', '--recibo-sha256', '--operadora', '--escopo', '--agente', '--tenant-nativo'];
+        if (args[0] !== '--dry-run' || args.length !== 1 + flags.length * 2 ||
+            flags.some(flag => args.filter(a => a === flag).length !== 1) ||
+            args.some(a => a.startsWith('--') && !['--dry-run', ...flags].includes(a)))
+            throw new Error('memory.prospective.apply-unavailable');
+        for (const flag of flags)
+            if (!value(flag) || value(flag).startsWith('--'))
+                throw new Error('memory.prospective.arguments');
+        const c = (0, manifest_1.exigirManifesto)();
+        const escopo = (0, escopo_escrita_1.exigirEscopoDeEscrita)(value('--escopo').split(','));
+        if (!escopo.has(value('--operadora')))
+            throw new Error('scope.thread.unauthorized');
+        for (const id of escopo)
+            (0, escopo_escrita_1.validarDiretorioDeThread)(c.raiz, id);
+        const evidence = path.join((0, estado_thread_1.estadoCanonico)(c.raiz, value('--operadora')), 'evidence');
+        const arquivo = path.resolve(value('--recibo'));
+        const evidenceLocal = path.join(c.raiz, '.orkastery/threads', value('--operadora'), 'evidence');
+        if (![evidence, evidenceLocal].includes(path.dirname(arquivo)))
+            throw new Error('scope.receipt.unauthorized');
+        const fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        let bruto;
+        try {
+            const st = fs.fstatSync(fd);
+            if (!st.isFile() || (st.mode & 0o777) !== 0o600 || st.uid !== process.getuid?.() ||
+                !fs.realpathSync(arquivo).startsWith(fs.realpathSync(evidence) + path.sep))
+                throw new Error('scope.receipt.unauthorized');
+            bruto = fs.readFileSync(fd, 'utf8');
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        if ((0, exports.hashProspectivo)(bruto) !== value('--recibo-sha256'))
+            throw new Error('memory.prospective.receipt-mismatch');
+        const plano = prepararVersaoProspectiva(c, JSON.parse(bruto), { reciboSha256: (0, exports.hashProspectivo)(bruto),
+            agente: value('--agente'), tenantNativo: value('--tenant-nativo'),
+            revisao: (0, node_child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: c.raiz, encoding: 'utf8' }).trim() });
+        // O plano integral continua privado: stdout e somente resumo, sem IDs, hashes de linhas ou conteudo.
+        console.log(JSON.stringify({ ...plano, entradas: undefined, quantidade: plano.entradas.length,
+            operadora: value('--operadora'), escopo: [...escopo], manifestoSha256: (0, exports.hashProspectivo)(fs.readFileSync(c.caminho, 'utf8')) }, null, 2));
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : '';
+        console.error(JSON.stringify({ erro: /^(memory|scope)\.[a-z.-]+$/.test(message) ? message : 'memory.prospective.invalid-input' }));
+        process.exitCode = 1;
+    }
+}

package/dist/modos-migracao.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * Migracao idempotente dos modos aposentados (I-43, T4).
+ *
+ * DOMICILIO UNICO da migracao. Ela e o unico lugar do produto que REESCREVE estado
+ * ja gravado por causa da aposentadoria, e por isso mora sozinha: `setup.ts` nunca
+ * foi escritor de YAML, e transforma-lo em um so para caber esta rotina misturaria
+ * dois formatos de arquivo no mesmo dono.
+ *
+ * O que ela faz e estreito de proposito:
+ *   - `orkastery.yaml`: tira modo aposentado de `conduction.allowed_modes`, e troca
+ *     `conduction.default_mode` aposentado pelo primeiro modo vivo.
+ *   - `.orkastery/setup.json`: descarta os blocos dos modos aposentados, que ja eram
+ *     inertes desde que `ORDEM_DOS_MODOS` encolheu (`lerSetup` normaliza contra a
+ *     matriz VIVA), mas continuavam ocupando o arquivo.
+ *
+ * O que ela NAO faz, e nao pode fazer: tocar em `thread.json`, `ledger.jsonl`,
+ * recibo ou MASTER log. P3 do GOAL e explicita, e e a metade que da sentido a outra
+ * metade: NENHUM HISTORICO E MIGRADO. Thread de 02/09 em `#Look` fica em `#Look` em
+ * disco para sempre, e e o leitor que continua aceitando (fx-modo-aposentado-leitor).
+ *
+ * IDEMPOTENTE: rodar de novo num projeto ja migrado nao escreve nada e devolve a
+ * lista vazia. Isso importa porque ela vai rodar em tres projetos deste VPS em
+ * momentos diferentes, e um deles pode ja ter sido migrado por outra sessao.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planejarMigracaoModos = planejarMigracaoModos;
+exports.migrarModosAposentados = migrarModosAposentados;
+exports.textoDaMigracaoModos = textoDaMigracaoModos;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const manifest_1 = require("./manifest");
+const ledger_1 = require("./ledger");
+const modos_1 = require("./modos");
+const util_1 = require("./util");
+const MARCA_BACKUP = 'migracao-modos-i43';
+/** Le a lista `[a, b, c]` de uma linha de YAML simples, como o manifesto escreve. */
+function lerListaInline(linha) {
+    const m = /^\s*allowed_modes:\s*\[(.*)\]\s*$/.exec(linha);
+    if (!m)
+        return null;
+    return m[1].split(',').map((x) => x.trim()).filter((x) => x.length > 0);
+}
+/**
+ * Planeja a migracao sem escrever nada.
+ *
+ * Separado de `migrarModosAposentados` pelo mesmo motivo de `planejarMigracaoMaster`:
+ * o dono precisa poder ver o diff antes de autorizar, e `--dry-run` nao pode ser um
+ * caminho de codigo diferente do que roda de verdade.
+ */
+function planejarMigracaoModos(raiz) {
+    const mudancas = [];
+    const yaml = path.join(raiz, manifest_1.NOME_MANIFESTO);
+    if (fs.existsSync(yaml)) {
+        for (const linha of fs.readFileSync(yaml, 'utf8').split('\n')) {
+            const lista = lerListaInline(linha);
+            if (lista) {
+                const vivos = lista.filter((m) => !(0, modos_1.modoAposentado)(m));
+                if (vivos.length !== lista.length) {
+                    mudancas.push({ arquivo: manifest_1.NOME_MANIFESTO, campo: 'conduction.allowed_modes',
+                        de: `[${lista.join(', ')}]`, para: `[${vivos.join(', ')}]` });
+                }
+                continue;
+            }
+            const d = /^\s*default_mode:\s*(\S+)\s*$/.exec(linha);
+            if (d && (0, modos_1.modoAposentado)(d[1])) {
+                mudancas.push({ arquivo: manifest_1.NOME_MANIFESTO, campo: 'conduction.default_mode',
+                    de: d[1], para: modos_1.ORDEM_DOS_MODOS[0] });
+            }
+        }
+    }
+    const setup = path.join((0, manifest_1.dirEstado)(raiz), 'setup.json');
+    if (fs.existsSync(setup)) {
+        try {
+            const bruto = JSON.parse(fs.readFileSync(setup, 'utf8'));
+            for (const morto of modos_1.MODOS_APOSENTADOS) {
+                if (bruto.modos && Object.hasOwn(bruto.modos, morto)) {
+                    mudancas.push({ arquivo: 'setup.json', campo: `modos.${morto}`, de: 'bloco inerte', para: '(removido)' });
+                }
+            }
+        }
+        catch { /* setup ilegivel nao e problema desta migracao; `lerSetup` ja reclama */ }
+    }
+    return mudancas;
+}
+/**
+ * Aplica a migracao, com backup e evento no ledger do projeto.
+ *
+ * O backup e condicao e nao cortesia: reescrever `orkastery.yaml` de um projeto vivo
+ * sem guardar o original seria exatamente o tipo de passo irreversivel silencioso que
+ * esta thread existe para remover do produto.
+ */
+function migrarModosAposentados(raiz, opcoes = {}) {
+    const mudancas = planejarMigracaoModos(raiz);
+    if (opcoes.dryRun || mudancas.length === 0) {
+        return { dryRun: opcoes.dryRun === true, mudancas, backup: null };
+    }
+    const estado = (0, manifest_1.dirEstado)(raiz);
+    fs.mkdirSync(estado, { recursive: true });
+    const backup = path.join(estado, MARCA_BACKUP);
+    if (fs.existsSync(backup))
+        throw new Error(`backup anterior exige inspecao: ${backup}`);
+    fs.mkdirSync(backup);
+    const hashes = {};
+    const guardar = (nome, conteudo) => {
+        fs.writeFileSync(path.join(backup, nome), conteudo, { flag: 'wx', encoding: 'utf8' });
+        hashes[nome] = (0, node_crypto_1.createHash)('sha256').update(conteudo).digest('hex');
+    };
+    const yaml = path.join(raiz, manifest_1.NOME_MANIFESTO);
+    if (mudancas.some((m) => m.arquivo === manifest_1.NOME_MANIFESTO) && fs.existsSync(yaml)) {
+        const original = fs.readFileSync(yaml, 'utf8');
+        guardar(manifest_1.NOME_MANIFESTO, original);
+        const novo = original.split('\n').map((linha) => {
+            const lista = lerListaInline(linha);
+            if (lista) {
+                const vivos = lista.filter((m) => !(0, modos_1.modoAposentado)(m));
+                return vivos.length === lista.length ? linha : linha.replace(/\[.*\]/, `[${vivos.join(', ')}]`);
+            }
+            const d = /^(\s*default_mode:\s*)(\S+)(\s*)$/.exec(linha);
+            return d && (0, modos_1.modoAposentado)(d[2]) ? `${d[1]}${modos_1.ORDEM_DOS_MODOS[0]}${d[3]}` : linha;
+        }).join('\n');
+        fs.writeFileSync(yaml, novo, 'utf8');
+    }
+    const setup = path.join(estado, 'setup.json');
+    if (mudancas.some((m) => m.arquivo === 'setup.json') && fs.existsSync(setup)) {
+        const original = fs.readFileSync(setup, 'utf8');
+        guardar('setup.json', original);
+        const bruto = JSON.parse(original);
+        for (const morto of modos_1.MODOS_APOSENTADOS)
+            if (bruto.modos)
+                delete bruto.modos[morto];
+        bruto.atualizadoEm = (0, util_1.agora)();
+        fs.writeFileSync(setup, JSON.stringify(bruto, null, 2) + '\n', 'utf8');
+    }
+    (0, ledger_1.registrar)(estado, 'projeto', 'modos_migrados', {
+        versao: 1,
+        por: (opcoes.por ?? 'nucleo ork').trim(),
+        mudancas,
+        backup,
+        hashes,
+        razao: 'I-43: modo aposentado sai da configuracao; nenhum historico e migrado (P3)',
+    });
+    return { dryRun: false, mudancas, backup };
+}
+/** Texto do `ork modos migrar`, com o antes e o depois de cada campo. */
+function textoDaMigracaoModos(r) {
+    if (r.mudancas.length === 0) {
+        return 'Nada a migrar: nenhum modo aposentado na configuracao deste projeto.';
+    }
+    const linhas = [r.dryRun ? 'Simulacao (--dry-run), nada foi gravado.' : 'Migracao aplicada.'];
+    for (const m of r.mudancas)
+        linhas.push(`  ${m.arquivo}  ${m.campo}`, `    de   ${m.de}`, `    para ${m.para}`);
+    if (r.backup)
+        linhas.push(`  backup  ${r.backup}`);
+    linhas.push('', 'Nenhum historico foi tocado: thread, ledger e recibo em modo aposentado ficam como estao.');
+    return linhas.join('\n');
+}