@neurcode-ai/cli 0.17.0 → 0.19.0

package/dist/commands/session-hook.js

@@ -22,10 +22,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveSessionForHook = resolveSessionForHook;
 exports.normalizeHookFilePathForRepo = normalizeHookFilePathForRepo;
 exports.hookFilePathCandidates = hookFilePathCandidates;
+exports.proposedSourceFromHookInput = proposedSourceFromHookInput;
 exports.evaluateNoActiveSessionWrite = evaluateNoActiveSessionWrite;
 exports.shouldKeepSessionActiveForPendingApproval = shouldKeepSessionActiveForPendingApproval;
+exports.reconcileTrustedAdapterPosture = reconcileTrustedAdapterPosture;
 exports.sessionHookCommand = sessionHookCommand;
 const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const governance_runtime_1 = require("@neurcode-ai/governance-runtime");
@@ -43,6 +46,8 @@ const structural_understanding_1 = require("../utils/structural-understanding");
 const consequence_nudges_1 = require("../utils/consequence-nudges");
 const agent_guard_supervisor_1 = require("../utils/agent-guard-supervisor");
 const local_repo_brain_1 = require("../utils/local-repo-brain");
+const proposed_change_analysis_1 = require("../utils/proposed-change-analysis");
+const repo_intelligence_v2_1 = require("../utils/repo-intelligence-v2");
 // ── Helpers ───────────────────────────────────────────────────────────────────
 /** Read the full hook JSON from stdin, or return {} on any error. */
 function readHookInput() {
@@ -409,6 +414,36 @@ function hookFilePathCandidates(hookInput) {
     }
     return Array.from(new Set(candidates));
 }
+function stringField(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim())
+            return value;
+    }
+    return null;
+}
+function proposedSourceFromHookInput(hookInput) {
+    const toolInput = hookInput['tool_input'] ??
+        hookInput['toolInput'] ??
+        {};
+    const direct = stringField(toolInput, ['content', 'file_content', 'fileContent', 'text']);
+    if (direct)
+        return { source: direct, sourceKind: 'write_content' };
+    const replacement = stringField(toolInput, ['new_string', 'newString', 'replacement', 'newText']);
+    if (replacement)
+        return { source: replacement, sourceKind: 'edit_new_string' };
+    const edits = toolInput['edits'] ?? toolInput['changes'];
+    if (Array.isArray(edits)) {
+        const parts = edits
+            .map((edit) => edit && typeof edit === 'object'
+            ? stringField(edit, ['new_string', 'newString', 'replacement', 'newText'])
+            : null)
+            .filter((value) => Boolean(value));
+        if (parts.length > 0)
+            return { source: parts.join('\n'), sourceKind: 'multi_edit_new_strings' };
+    }
+    return { source: null, sourceKind: 'not_available' };
+}
 function runtimeMode(session) {
     return session.contract.runtimeMode === 'strict' ||
         session.contract.runtimeMode === 'paused' ||
@@ -416,9 +451,92 @@ function runtimeMode(session) {
         ? session.contract.runtimeMode
         : 'strict';
 }
+function repoSymbolDuplicateMode(session) {
+    const mode = session.contract.repoSymbolDuplicateMode;
+    return mode === 'off' || mode === 'warn' || mode === 'block' ? mode : 'warn';
+}
+function repoSymbolPolicyMessage(policy) {
+    const first = policy.findings[0];
+    if (!first)
+        return policy.reason;
+    const modeSuffix = policy.verdict === 'block'
+        ? 'Policy mode: block. Reuse or rename the symbol, or intentionally relax repoSymbolDuplicateMode.'
+        : 'Policy mode: warn. Review the existing symbol before continuing.';
+    return `${first.message} ${modeSuffix}`;
+}
+function classifyClarification(prompt) {
+    const compact = prompt
+        .replace(/```[\s\S]*?```/g, ' ')
+        .split(/\r?\n/)
+        .filter((line) => {
+        const trimmed = line.trim();
+        if (/^(?:diff --git |index [0-9a-f]{6,}|@@ |--- |\+\+\+ |Binary files )/.test(trimmed))
+            return false;
+        return !/^[+-](?!\s)/.test(trimmed);
+    })
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!compact)
+        return 'Human follow-up recorded without textual content.';
+    if (/^(?:yes|no|ok|okay|sure|continue|proceed|approved?|denied?|option\s+[a-z0-9]+|[a-z0-9]+)$/i.test(compact)) {
+        return 'Short human clarification referencing the active agent context.';
+    }
+    if (compact.length <= 80) {
+        return 'Brief human clarification recorded against the active agent proposal.';
+    }
+    return 'Detailed human clarification recorded against the active governed session.';
+}
+function acceptedProposalContext(session, rawPrompt) {
+    const pendingProposal = [...(session.contract.planAmendmentProposals ?? [])]
+        .reverse()
+        .find((proposal) => proposal.status === 'pending');
+    const activePlan = session.contract.agentPlan;
+    return {
+        schemaVersion: 'neurcode.intent-continuity-context.v1',
+        latestUserClarification: {
+            summary: classifyClarification(rawPrompt),
+            promptLength: rawPrompt.length,
+            promptHash: (0, crypto_1.createHash)('sha256').update(rawPrompt).digest('hex'),
+            recordedAt: new Date().toISOString(),
+            source: 'user_prompt_submit',
+        },
+        acceptedAgentProposal: activePlan
+            ? {
+                activePlanRevision: (0, governance_runtime_1.activeAgentPlanRevision)(session.contract),
+                summary: activePlan.summary || null,
+                expectedFiles: activePlan.expectedFiles,
+                expectedGlobs: activePlan.expectedGlobs,
+                constraints: activePlan.constraints,
+                risks: activePlan.risks,
+                source: activePlan.source,
+            }
+            : null,
+        pendingPlanAmendment: pendingProposal
+            ? {
+                proposalId: pendingProposal.proposalId,
+                previousRevision: pendingProposal.previousRevision,
+                proposedBy: pendingProposal.proposedBy,
+                reason: pendingProposal.reason,
+                riskLevel: pendingProposal.risk.level,
+                addedFiles: pendingProposal.risk.addedFiles,
+                addedGlobs: pendingProposal.risk.addedGlobs,
+                status: pendingProposal.status,
+            }
+            : null,
+        privacy: {
+            sourceUploaded: false,
+            sourceIncluded: false,
+            rawPromptStored: false,
+            summaryOnly: true,
+        },
+    };
+}
 function blockContext(input) {
     const isApproval = input.blockType === 'approval_required_boundary';
     const isScope = input.blockType === 'scope_violation_or_task_expansion';
+    const isRepoSymbolDuplicate = input.blockType === 'repo_symbol_duplicate_policy';
+    const isStructuralPolicy = input.blockType === 'structural_policy_violation';
     return {
         schemaVersion: 'neurcode.runtime-block.v1',
         blockType: input.blockType,
@@ -429,16 +547,24 @@ function blockContext(input) {
             ? 'exact_path_approval'
             : isScope
                 ? 'scope_amendment'
-                : input.blockType === 'profile_or_runtime_health_block'
-                    ? 'runtime_health_recovery'
-                    : 'split_tool_call',
+                : isRepoSymbolDuplicate
+                    ? 'symbol_reuse_or_policy_decision'
+                    : isStructuralPolicy
+                        ? 'structural_policy_remediation'
+                        : input.blockType === 'profile_or_runtime_health_block'
+                            ? 'runtime_health_recovery'
+                            : 'split_tool_call',
         operatorActionLabel: isApproval
             ? 'Approve exact path / Deny'
             : isScope
                 ? 'Approve task expansion / Amend scope / Deny'
-                : input.blockType === 'profile_or_runtime_health_block'
-                    ? 'Refresh or restart runtime'
-                    : 'Split into one file per tool call',
+                : isRepoSymbolDuplicate
+                    ? 'Reuse existing symbol / Rename / Relax policy'
+                    : isStructuralPolicy
+                        ? 'Remediate structural policy / Obtain required approval'
+                        : input.blockType === 'profile_or_runtime_health_block'
+                            ? 'Refresh or restart runtime'
+                            : 'Split into one file per tool call',
         suggestedApprovalPath: isApproval ? input.suggestedApprovalPath || input.filePath || null : null,
         owners: input.owners || [],
         proposalId: input.proposalId || null,
@@ -446,9 +572,13 @@ function blockContext(input) {
             ? 'Approve only the exact path for this session, or deny the write.'
             : isScope
                 ? 'Accept the pending scope amendment or re-plan locally, then retry the write.'
-                : input.blockType === 'profile_or_runtime_health_block'
-                    ? 'Refresh the governance profile or restart the active governed session.'
-                    : 'Retry as separate single-file edits so each path can be governed.'),
+                : isRepoSymbolDuplicate
+                    ? 'Reuse or rename the duplicate symbol, or change repoSymbolDuplicateMode with an explicit rationale.'
+                    : isStructuralPolicy
+                        ? 'Review the matched deterministic facts and remediation, then retry after fixing the change or recording an authorized approval.'
+                        : input.blockType === 'profile_or_runtime_health_block'
+                            ? 'Refresh the governance profile or restart the active governed session.'
+                            : 'Retry as separate single-file edits so each path can be governed.'),
     };
 }
 const NO_ACTIVE_SESSION_SCOPE_SENTINEL = '__neurcode_no_active_session_scope__';
@@ -485,7 +615,9 @@ function blockTypeFromEvent(event) {
         if (value === 'approval_required_boundary' ||
             value === 'scope_violation_or_task_expansion' ||
             value === 'profile_or_runtime_health_block' ||
-            value === 'multi_file_or_tool_shape_block') {
+            value === 'multi_file_or_tool_shape_block' ||
+            value === 'repo_symbol_duplicate_policy' ||
+            value === 'structural_policy_violation') {
             return value;
         }
     }
@@ -546,6 +678,9 @@ function latestUnresolvedActionableBlock(session) {
 function shouldKeepSessionActiveForPendingApproval(session, pendingApproval) {
     if (!pendingApproval)
         return false;
+    if (pendingApproval.blockType === 'profile_or_runtime_health_block') {
+        return false;
+    }
     if (pendingApproval.blockType && pendingApproval.blockType !== 'approval_required_boundary') {
         return true;
     }
@@ -747,6 +882,7 @@ async function maybeContinueActiveClaudeSession(repoRoot, rawPrompt, intentSelec
     if (decision.action === 'start_new_session')
         return null;
     if (decision.action === 'record_operator_note') {
+        const continuityContext = acceptedProposalContext(activeSession, rawPrompt);
         (0, governance_runtime_1.appendEvent)(repoRoot, activeSession.sessionId, {
             type: 'user_decision',
             ts: new Date().toISOString(),
@@ -754,6 +890,7 @@ async function maybeContinueActiveClaudeSession(repoRoot, rawPrompt, intentSelec
             message: 'Human follow-up prompt recorded without changing the active governed plan.',
             detail: {
                 intentContinuity: decision.detail,
+                continuityContext,
                 reason: decision.reason,
                 confidence: decision.confidence,
             },
@@ -778,6 +915,7 @@ async function maybeContinueActiveClaudeSession(repoRoot, rawPrompt, intentSelec
             : `Human follow-up prompt updated active plan revision ${amended.previousRevision} -> ${amended.revision}.`,
         detail: {
             intentContinuity: decision.detail,
+            continuityContext: acceptedProposalContext(session, rawPrompt),
             reason: decision.reason,
             confidence: decision.confidence,
             planAmendment: {
@@ -895,8 +1033,25 @@ async function handleStart(cmdCwd) {
         // Fail open — don't break the agent turn
     }
 }
+const HARD_PREWRITE_ADAPTERS = new Set(['claude-code-hooks', 'copilot-hooks']);
+/**
+ * Bind the attested host posture to the session's established launcher posture.
+ * A governed session launched by a cooperative or observe-only agent can never
+ * be re-labelled as host-enforced hard pre-write by a later check, even if the
+ * check declares a hard adapter string. Changing adapters requires an explicit
+ * re-handshake that re-launches the session. This is posture binding, not a
+ * cryptographic host-attestation claim.
+ */
+function reconcileTrustedAdapterPosture(declared, launched) {
+    if (!launched || declared === launched)
+        return { adapterId: declared, downgraded: false };
+    if (HARD_PREWRITE_ADAPTERS.has(declared) && !HARD_PREWRITE_ADAPTERS.has(launched)) {
+        return { adapterId: launched, downgraded: true };
+    }
+    return { adapterId: declared, downgraded: false };
+}
 /** PreToolUse — check a pending Edit/Write/MultiEdit before it lands. */
-async function handleCheck(cmdCwd) {
+async function handleCheck(cmdCwd, trustedAdapterId, trustedTiming) {
     const hookInput = readHookInput();
     const effectiveCwd = cwdFromHookInput(hookInput, cmdCwd);
     const repoRoot = (0, v0_governance_1.resolveRepoRoot)(effectiveCwd);
@@ -1312,6 +1467,88 @@ async function handleCheck(cmdCwd) {
                 `${planCoherencePolicy.reason} Proceeding — recorded in session.`,
         };
     }
+    const launchedAdapter = (0, agent_session_launcher_1.latestAgentLauncherState)(session)?.agent.adapter;
+    const adapterPosture = reconcileTrustedAdapterPosture(trustedAdapterId, launchedAdapter);
+    if (adapterPosture.downgraded) {
+        diagnostic(`trusted adapter ${trustedAdapterId} cannot host-enforce a session launched by ${launchedAdapter}; ` +
+            `attesting ${adapterPosture.adapterId} posture. Re-handshake to change adapters.`);
+    }
+    const proposedSource = proposedSourceFromHookInput(hookInput);
+    const proposedChange = (0, proposed_change_analysis_1.analyzeProposedChange)({
+        repoRoot,
+        filePath,
+        proposedSource: proposedSource.source,
+        sourceKind: proposedSource.sourceKind,
+        adapterId: adapterPosture.adapterId,
+        timing: trustedTiming,
+        sessionId: session.sessionId,
+        planRevision: (0, governance_runtime_1.activeAgentPlanRevision)(session.contract),
+        proposedChange: hookInput['proposed_change'] ?? hookInput['proposedChange'],
+    });
+    let repoSymbolPolicy = (0, local_repo_brain_1.evaluateRepoSymbolDuplicatePolicy)({
+        projectRoot: repoRoot,
+        filePath,
+        proposedSource: proposedSource.source,
+        proposedSymbols: proposedChange.localSymbols,
+        policyMode: repoSymbolDuplicateMode(session),
+    });
+    repoSymbolPolicy = {
+        ...repoSymbolPolicy,
+        reason: repoSymbolPolicy.verdict === 'not_evaluated'
+            ? `${repoSymbolPolicy.reason} Source extraction: ${proposedSource.sourceKind}; ` +
+                `content availability: ${proposedChange.envelope.content.availabilityReason}.`
+            : repoSymbolPolicy.reason,
+    };
+    const repoIntelligence = await (0, repo_intelligence_v2_1.evaluateLocalRepoIntelligenceV2)({
+        repoRoot,
+        change: proposedChange.envelope,
+        approvedPaths: session.contract.approvedPaths,
+        approvalGrants: session.contract.approvalGrants,
+    });
+    if (result.verdict !== 'block' && repoSymbolPolicy.verdict === 'block') {
+        result = {
+            ...result,
+            verdict: 'block',
+            blockType: 'repo_symbol_duplicate_policy',
+            message: `⏸ Neurcode: ${repoSymbolPolicyMessage(repoSymbolPolicy)}`,
+            options: ['narrow', 'replan'],
+        };
+    }
+    else if (result.verdict === 'ok' && repoSymbolPolicy.verdict === 'warn') {
+        result = {
+            ...result,
+            verdict: 'warn',
+            blockType: 'repo_symbol_duplicate_policy',
+            message: `⚠️ Neurcode: ${repoSymbolPolicyMessage(repoSymbolPolicy)}`,
+            options: ['continue', 'replan'],
+        };
+    }
+    else if (result.verdict === 'warn' && repoSymbolPolicy.verdict === 'warn') {
+        result = {
+            ...result,
+            message: `${result.message} ${repoSymbolPolicyMessage(repoSymbolPolicy)}`,
+        };
+    }
+    if (result.verdict !== 'block' && repoIntelligence.evaluation.verdict === 'block') {
+        const first = repoIntelligence.evaluation.findings.find((finding) => finding.verdict === 'block');
+        result = {
+            ...result,
+            verdict: 'block',
+            blockType: 'structural_policy_violation',
+            message: `⏸ Neurcode: ${first?.explanation ?? 'A deterministic structural policy blocked this change.'} ${first?.remediation ?? ''}`.trim(),
+            options: ['narrow', 'replan'],
+        };
+    }
+    else if (result.verdict === 'ok' && repoIntelligence.evaluation.verdict === 'warn') {
+        const first = repoIntelligence.evaluation.findings[0];
+        result = {
+            ...result,
+            verdict: 'warn',
+            blockType: 'structural_policy_violation',
+            message: `⚠️ Neurcode: ${first?.explanation ?? 'A deterministic structural policy warned on this change.'} ${first?.remediation ?? ''}`.trim(),
+            options: ['continue', 'replan'],
+        };
+    }
     // ── Record the event ─────────────────────────────────────────────────────
     // Tag every check with the agent-plan revision that was active when it ran,
     // so the evidence record can answer "which plan version governed this edit?".
@@ -1353,6 +1590,16 @@ async function handleCheck(cmdCwd) {
                     dependents: architectureEdit.dependents,
                     message: architectureEdit.message,
                 },
+                repoSymbolPolicy,
+                repoSymbolPolicySource: proposedSource.sourceKind,
+                proposedChange: proposedChange.envelope,
+                repoIntelligence: repoIntelligence.evidence,
+                structuralPolicy: {
+                    configured: repoIntelligence.policyConfigured,
+                    schemaVersion: repoIntelligence.policyConfigured
+                        ? 'neurcode.structural-policy-artifact.v2'
+                        : null,
+                },
                 boundaryVerdict,
                 activePlanRevision,
                 planPresent: Boolean(session.contract.agentPlan),
@@ -1402,6 +1649,7 @@ async function handleCheck(cmdCwd) {
         // Include machine-readable approvalContext when the block is approval-required,
         // so the agent can surface a structured approval request to the human.
         denyPreToolUse(enrichedMessage, {
+            repoSymbolPolicy,
             ...(result.approvalContext ? { approvalContext: result.approvalContext } : {}),
             ...(result.blockType
                 ? {
@@ -1440,6 +1688,7 @@ async function handleCheck(cmdCwd) {
                 hookEventName: 'PreToolUse',
                 permissionDecision: 'allow',
                 reason,
+                repoSymbolPolicy,
             },
         }) + '\n');
         process.exit(0);
@@ -1661,12 +1910,28 @@ function sessionHookCommand(program) {
         const opts = cmd.opts();
         await handleStart(opts.dir || process.cwd());
     });
-    cmd
+    const check = cmd
         .command('check')
         .description('Check a pending edit against the active session (PreToolUse hook)')
-        .action(async () => {
+        .option('--trusted-adapter <adapter>', 'Ingress-bound adapter identity declared by the installed host hook')
+        .option('--trusted-timing <timing>', 'Ingress-bound event timing', 'before_write');
+    check.action(async (subOpts) => {
         const opts = cmd.opts();
-        await handleCheck(opts.dir || process.cwd());
+        const adapters = [
+            'claude-code-hooks', 'copilot-hooks', 'generic-mcp', 'codex-mcp',
+            'cursor-mcp', 'vscode-extension', 'github-action',
+        ];
+        const timings = ['before_write', 'during_write', 'after_write', 'ci'];
+        // No implicit hard pre-write default: an unspecified adapter is the
+        // non-privileged cooperative generic ingress, never Claude host enforcement.
+        const trustedAdapter = subOpts.trustedAdapter ?? 'generic-mcp';
+        if (!adapters.includes(trustedAdapter)) {
+            throw new Error(`Unsupported trusted hook adapter: ${trustedAdapter}`);
+        }
+        if (!timings.includes(subOpts.trustedTiming)) {
+            throw new Error(`Unsupported trusted hook timing: ${subOpts.trustedTiming}`);
+        }
+        await handleCheck(opts.dir || process.cwd(), trustedAdapter, subOpts.trustedTiming);
     });
     cmd
         .command('finish')