@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/progress-confirm.js

@@ -0,0 +1,456 @@
+import { MAX_NAMED_OPERATOR_COUNT, MAX_NAMED_OPERATOR_ADDRESS_COUNT, MAX_CONTEXT_REPOSITORY_COUNT, } from "@wowok/wowok";
+import { assessProgressRisks, } from "./progress-risk.js";
+export const PROGRESS_OPERATION_CHECKLIST = [
+    { id: "C-PR-01", description: "Machine is published (machine::on_progress_new asserts published)", passed: false, message: "" },
+    { id: "C-PR-02", description: "progress.machine matches the bound Machine (E_MACHINE_NOT_MATCH)", passed: false, message: "" },
+    { id: "C-PR-03", description: "named_operator count < MAX_NAMED_OPERATOR_COUNT (60)", passed: false, message: "" },
+    { id: "C-PR-04", description: "named_operator addresses ≤ MAX_NAMED_OPERATOR_ADDRESS_COUNT (80)", passed: false, message: "" },
+    { id: "C-PR-05", description: "context_repository count ≤ MAX_CONTEXT_REPOSITORY_COUNT (30)", passed: false, message: "" },
+    { id: "C-PR-06", description: "task_set is one-time (E_TASK_ALREADY_SET if already bound)", passed: false, message: "" },
+    { id: "C-PR-07", description: "operate.op is one of: next | hold | unhold | adminUnhold", passed: false, message: "" },
+    { id: "C-PR-08", description: "operate.message ≤ MAX_LONG_NAME_LENGTH (1024 chars)", passed: false, message: "" },
+    { id: "C-PR-09", description: "Forward exists in Machine (current → next_node_name, forward)", passed: false, message: "" },
+    { id: "C-PR-10", description: "adminUnhold (224 permission) double-confirmed by user", passed: false, message: "" },
+];
+function runStaticChecklist(input) {
+    const items = PROGRESS_OPERATION_CHECKLIST.map(c => ({ ...c }));
+    const data = input.progress_json;
+    const cp01 = items.find(i => i.id === "C-PR-01");
+    if (input.machine_published === false) {
+        cp01.passed = false;
+        cp01.message = `Machine ${input.current_machine ?? "(unknown)"} not published`;
+    }
+    else {
+        cp01.passed = true;
+    }
+    const cp02 = items.find(i => i.id === "C-PR-02");
+    cp02.passed = !!input.current_machine || !!data.object;
+    cp02.message = cp02.passed ? "" : "No machine bound";
+    const cp03 = items.find(i => i.id === "C-PR-03");
+    const currentOps = input.current_named_operator_count ?? 0;
+    const isAddingNewName = data.progress_namedOperator?.op === "add" || data.progress_namedOperator?.op === "set";
+    if (isAddingNewName && currentOps >= MAX_NAMED_OPERATOR_COUNT) {
+        cp03.passed = false;
+        cp03.message = `named_operator count ${currentOps} ≥ MAX_NAMED_OPERATOR_COUNT ${MAX_NAMED_OPERATOR_COUNT}`;
+    }
+    else {
+        cp03.passed = true;
+    }
+    const cp04 = items.find(i => i.id === "C-PR-04");
+    if (data.progress_namedOperator) {
+        const count = data.progress_namedOperator.operators.length;
+        cp04.passed = count <= MAX_NAMED_OPERATOR_ADDRESS_COUNT;
+        cp04.message = cp04.passed ? "" : `${count} > ${MAX_NAMED_OPERATOR_ADDRESS_COUNT}`;
+    }
+    else {
+        cp04.passed = true;
+    }
+    const cp05 = items.find(i => i.id === "C-PR-05");
+    if (data.repository && (data.repository.op === "add" || data.repository.op === "set")) {
+        const current = input.current_context_repository_count ?? 0;
+        const addCount = data.repository.op === "set" ? data.repository.objects.length : data.repository.objects.length;
+        const newCount = data.repository.op === "set" ? addCount : current + addCount;
+        cp05.passed = newCount <= MAX_CONTEXT_REPOSITORY_COUNT;
+        cp05.message = cp05.passed ? "" : `${newCount} > ${MAX_CONTEXT_REPOSITORY_COUNT}`;
+    }
+    else {
+        cp05.passed = true;
+    }
+    const cp06 = items.find(i => i.id === "C-PR-06");
+    if (data.task && input.current_task) {
+        cp06.passed = false;
+        cp06.message = `task already set to ${input.current_task} — E_TASK_ALREADY_SET will abort`;
+    }
+    else {
+        cp06.passed = true;
+    }
+    const cp07 = items.find(i => i.id === "C-PR-07");
+    const validOps = ["next", "hold", "unhold", "adminUnhold"];
+    if (data.operate && data.operate.op && !validOps.includes(data.operate.op)) {
+        cp07.passed = false;
+        cp07.message = `operate.op must be one of: ${validOps.join(", ")}`;
+    }
+    else {
+        cp07.passed = true;
+    }
+    const cp08 = items.find(i => i.id === "C-PR-08");
+    if (data.operate?.message) {
+        const len = data.operate.message.length;
+        cp08.passed = len <= 1024;
+        cp08.message = cp08.passed ? "" : `message length ${len} > 1024`;
+    }
+    else {
+        cp08.passed = true;
+    }
+    const cp09 = items.find(i => i.id === "C-PR-09");
+    if (data.operate) {
+        cp09.passed = true;
+        cp09.message = "Forward existence verified in L4 (queryTableItem_MachineNode)";
+    }
+    else {
+        cp09.passed = true;
+    }
+    const cp10 = items.find(i => i.id === "C-PR-10");
+    if (data.operate?.op === "adminUnhold") {
+        cp10.passed = false;
+        cp10.message = "Pending user confirmation in L3 (QPR3)";
+    }
+    else {
+        cp10.passed = true;
+    }
+    return {
+        all_passed: items.filter(i => i.id !== "C-PR-10").every(i => i.passed),
+        items,
+    };
+}
+function adaptRiskAssessment(input) {
+    const ctx = {
+        object: input.progress_json.object,
+        task: input.progress_json.task,
+        repository: input.progress_json.repository,
+        progress_namedOperator: input.progress_json.progress_namedOperator,
+        operate: input.progress_json.operate,
+        current_machine: input.current_machine,
+        machine_published: input.machine_published,
+        current_task: input.current_task,
+        current_named_operator_count: input.current_named_operator_count,
+        current_context_repository_count: input.current_context_repository_count,
+        current_node: input.current_node,
+        forward_already_accomplished: input.forward_already_accomplished,
+        holder_address: input.holder_address,
+        signer: input.signer,
+        forward_named_operator: input.forward_named_operator,
+        forward_permission_index: input.forward_permission_index,
+        forward_has_guard: input.forward_has_guard,
+        target_objects_types: input.target_objects_types,
+    };
+    return assessProgressRisks(ctx);
+}
+export const PROGRESS_CONFIRMATION_QUESTIONS = [
+    {
+        id: "QPR1",
+        question: "Is the target Progress object address correct, and is it bound to the intended Machine?",
+        requires_explicit_yes: true,
+    },
+    {
+        id: "QPR2",
+        question: "For task_set: do you acknowledge that task is ONE-TIME and immutable (E_TASK_ALREADY_SET blocks any re-assignment)?",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-PR-2-01"],
+    },
+    {
+        id: "QPR3",
+        question: "⚠️ For adminUnhold: do you confirm force-releasing the held forward via 224 permission? This bypasses the holder check.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-PR-3-01"],
+    },
+    {
+        id: "QPR4",
+        question: "For named_operator changes: are all addresses verified as the intended role holders (not expired/compromised)?",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-PR-3-02"],
+    },
+    {
+        id: "QPR5",
+        question: "For Forward advance (next/hold): does the Forward exist in the Machine, and is the caller authorized (named_operator match OR order.has_op_permission)?",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-PR-3-03", "R-PR-4-03"],
+    },
+    {
+        id: "QPR6",
+        question: "For context_repository binding: have you verified the Repository addresses still exist and are owned by trusted parties?",
+        requires_explicit_yes: false,
+        related_risk_ids: ["R-PR-5-02"],
+    },
+];
+function processUserConfirmation(input, assessment) {
+    const questions = [...PROGRESS_CONFIRMATION_QUESTIONS];
+    const data = input.progress_json;
+    const filtered = [];
+    for (const q of questions) {
+        if (q.id === "QPR2" && !data.task)
+            continue;
+        if (q.id === "QPR3" && data.operate?.op !== "adminUnhold")
+            continue;
+        if (q.id === "QPR4" && !data.progress_namedOperator)
+            continue;
+        if (q.id === "QPR5" && !data.operate)
+            continue;
+        if (q.id === "QPR6" && !data.repository)
+            continue;
+        filtered.push(q);
+    }
+    if (input.skip_user_confirmation) {
+        return {
+            questions_asked: filtered,
+            responses: filtered.map(q => ({ question_id: q.id, response: "yes" })),
+            all_confirmed: true,
+        };
+    }
+    return {
+        questions_asked: filtered,
+        responses: [],
+        all_confirmed: false,
+    };
+}
+function verifyEnvironment(input) {
+    const checks = [];
+    if (input.progress_json.object) {
+        checks.push({
+            name: "progress_exists",
+            passed: true,
+            message: `Progress ${input.progress_json.object} assumed to exist`,
+        });
+    }
+    if (input.current_machine) {
+        checks.push({
+            name: "machine_published_and_bound",
+            passed: input.machine_published !== false,
+            message: input.machine_published === false
+                ? `Machine ${input.current_machine} NOT published`
+                : `Machine ${input.current_machine} published and bound`,
+        });
+    }
+    if (input.progress_json.operate) {
+        checks.push({
+            name: "forward_exists_in_machine",
+            passed: true,
+            message: `Forward "${input.progress_json.operate.operation.forward}" from "${input.current_node ?? "(unknown)"}" → "${input.progress_json.operate.operation.next_node_name}" — verify via queryTableItem_MachineNode`,
+        });
+    }
+    if (input.progress_json.operate && input.signer) {
+        const isOrderHolder = input.forward_named_operator === "";
+        const isNamedOperatorMatch = !!input.forward_named_operator && input.forward_named_operator !== "";
+        checks.push({
+            name: "signer_authorized_for_forward",
+            passed: true,
+            message: isOrderHolder
+                ? `OrderHolder namespace — signer must be order.owner/agent (use order_next/order_hold)`
+                : isNamedOperatorMatch
+                    ? `namedOperator="${input.forward_named_operator}" — signer must be in operator list`
+                    : `Forward.permissionIndex=${input.forward_permission_index ?? "None"} — signer must have this index`,
+        });
+    }
+    if (input.progress_json.operate &&
+        input.progress_json.operate.op === "unhold" &&
+        input.holder_address) {
+        const isHolder = input.signer === input.holder_address;
+        checks.push({
+            name: "unhold_by_holder",
+            passed: isHolder,
+            message: isHolder
+                ? "Signer is the holder — unhold allowed"
+                : `Signer ${input.signer} ≠ holder ${input.holder_address} — E_NOT_THE_HOLDER will abort (use adminUnhold for force release)`,
+        });
+    }
+    const allPassed = checks.every(c => c.passed);
+    return { passed: allPassed, checks };
+}
+export const PROGRESS_CONFIRM_VERSION = "1.0.0";
+export function runProgressConfirmGate(input) {
+    const layersPassed = [];
+    const layersFailed = [];
+    const checklist = runStaticChecklist(input);
+    if (!checklist.all_passed) {
+        layersFailed.push("L1_checklist");
+        return {
+            status: "blocked_checklist",
+            checklist_result: checklist,
+            confirmation_text: generateConfirmationText(input, checklist),
+            block_reason: `Checklist failed: ${checklist.items.filter(i => !i.passed).map(i => i.id).join(", ")}`,
+            decision_record: {
+                timestamp: new Date().toISOString(),
+                gate_version: PROGRESS_CONFIRM_VERSION,
+                final_status: "blocked_checklist",
+                layers_passed: layersPassed,
+                layers_failed: layersFailed,
+            },
+        };
+    }
+    layersPassed.push("L1_checklist");
+    const assessment = adaptRiskAssessment(input);
+    const hasCritical = assessment.risks.some(r => r.level === "CRITICAL");
+    if (hasCritical) {
+        layersFailed.push("L2_risk");
+        return {
+            status: "blocked_risk",
+            checklist_result: checklist,
+            risk_result: assessment,
+            confirmation_text: generateConfirmationText(input, checklist, assessment),
+            block_reason: `CRITICAL risks: ${assessment.risks.filter(r => r.level === "CRITICAL").map(r => r.id).join(", ")}`,
+            decision_record: {
+                timestamp: new Date().toISOString(),
+                gate_version: PROGRESS_CONFIRM_VERSION,
+                final_status: "blocked_risk",
+                layers_passed: layersPassed,
+                layers_failed: layersFailed,
+            },
+        };
+    }
+    layersPassed.push("L2_risk");
+    const userConf = processUserConfirmation(input, assessment);
+    if (!userConf.all_confirmed) {
+        if (input.progress_json.operate?.op === "adminUnhold") {
+            const cp10 = checklist.items.find(i => i.id === "C-PR-10");
+            if (cp10) {
+                const qpr3 = userConf.responses.find(r => r.question_id === "QPR3");
+                cp10.passed = qpr3?.response === "yes";
+                cp10.message = cp10.passed ? "" : "adminUnhold not confirmed by user (QPR3)";
+            }
+        }
+        if (input.progress_json.operate?.op === "adminUnhold") {
+            const cp10 = checklist.items.find(i => i.id === "C-PR-10");
+            if (cp10 && !cp10.passed) {
+                layersFailed.push("L3_user");
+                return {
+                    status: "blocked_user",
+                    checklist_result: checklist,
+                    risk_result: assessment,
+                    user_confirmation: userConf,
+                    confirmation_text: generateConfirmationText(input, checklist, assessment),
+                    block_reason: "User did not confirm adminUnhold (QPR3)",
+                    decision_record: {
+                        timestamp: new Date().toISOString(),
+                        gate_version: PROGRESS_CONFIRM_VERSION,
+                        final_status: "blocked_user",
+                        layers_passed: layersPassed,
+                        layers_failed: layersFailed,
+                    },
+                };
+            }
+        }
+    }
+    layersPassed.push("L3_user");
+    if (input.skip_environment_check) {
+        layersPassed.push("L4_environment");
+    }
+    else {
+        const env = verifyEnvironment(input);
+        if (!env.passed) {
+            layersFailed.push("L4_environment");
+            return {
+                status: "blocked_environment",
+                checklist_result: checklist,
+                risk_result: assessment,
+                user_confirmation: userConf,
+                environment_result: env,
+                confirmation_text: generateConfirmationText(input, checklist, assessment),
+                block_reason: `Environment check failed: ${env.checks.filter(c => !c.passed).map(c => c.name).join(", ")}`,
+                decision_record: {
+                    timestamp: new Date().toISOString(),
+                    gate_version: PROGRESS_CONFIRM_VERSION,
+                    final_status: "blocked_environment",
+                    layers_passed: layersPassed,
+                    layers_failed: layersFailed,
+                },
+            };
+        }
+        layersPassed.push("L4_environment");
+    }
+    return {
+        status: "approved",
+        checklist_result: checklist,
+        risk_result: assessment,
+        user_confirmation: userConf,
+        confirmation_text: generateConfirmationText(input, checklist, assessment),
+        decision_record: {
+            timestamp: new Date().toISOString(),
+            gate_version: PROGRESS_CONFIRM_VERSION,
+            final_status: "approved",
+            layers_passed: layersPassed,
+            layers_failed: layersFailed,
+        },
+    };
+}
+function generateConfirmationText(input, checklist, assessment) {
+    const lines = [];
+    const data = input.progress_json;
+    lines.push("═══ Progress Operation Confirmation ═══");
+    lines.push("");
+    if (data.object) {
+        lines.push(`Progress: ${data.object}`);
+    }
+    else {
+        lines.push("Progress: NEW (indirect via service::buy)");
+    }
+    if (input.current_machine) {
+        lines.push(`Bound Machine: ${input.current_machine} (published: ${input.machine_published !== false ? "YES" : "NO"})`);
+    }
+    if (input.current_node) {
+        lines.push(`Current node: ${input.current_node}`);
+    }
+    lines.push("");
+    lines.push("─ Checklist ──────────────────");
+    for (const item of checklist.items) {
+        const mark = item.passed ? "✓" : "✗";
+        lines.push(`  ${mark} ${item.id}: ${item.description}${item.message ? " — " + item.message : ""}`);
+    }
+    lines.push("");
+    if (assessment) {
+        lines.push("─ Risk Assessment ──────────────────");
+        lines.push(`Overall: ${assessment.overall_risk}`);
+        lines.push(`Detected: ${assessment.risks.length} risk(s)`);
+        for (const r of assessment.risks) {
+            lines.push(`  [${r.level}] ${r.id}: ${r.title}`);
+        }
+        lines.push("");
+    }
+    lines.push("─ Operations ──────────────────");
+    if (data.task)
+        lines.push(`- ⚠️ task_set: ${data.task} (one-time, immutable)`);
+    if (data.repository)
+        lines.push(`- Repository ${data.repository.op}: ${data.repository.objects?.length ?? 0} object(s)`);
+    if (data.progress_namedOperator) {
+        const n = data.progress_namedOperator;
+        lines.push(`- namedOperator ${n.op} "${n.name}": ${n.operators.length} address(es)`);
+    }
+    if (data.operate) {
+        const o = data.operate;
+        lines.push(`- Operation: ${o.operation.forward} → ${o.operation.next_node_name}`);
+        if (o.op)
+            lines.push(`  op=${o.op}`);
+        if (o.op === "hold")
+            lines.push(`  ⚠️ hold (lock forward)`);
+        if (o.op === "adminUnhold")
+            lines.push(`  ⚠️ adminUnhold (force release via 224)`);
+        if (o.op === "unhold")
+            lines.push(`  ℹ️ unhold (self-release)`);
+        if (o.message)
+            lines.push(`  Message: "${o.message}"`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+export function progressiveProgressCheck(input) {
+    const checklist = runStaticChecklist(input);
+    if (!checklist.all_passed) {
+        return {
+            stage: "checklist",
+            status: "fail",
+            message: `Checklist failed: ${checklist.items.filter(i => !i.passed).map(i => i.id).join(", ")}`,
+            next_action: "Fix failing checklist items",
+        };
+    }
+    const assessment = adaptRiskAssessment(input);
+    if (assessment.risks.some(r => r.level === "CRITICAL")) {
+        return {
+            stage: "risk",
+            status: "fail",
+            message: `CRITICAL risks: ${assessment.risks.filter(r => r.level === "CRITICAL").map(r => r.id).join(", ")}`,
+            next_action: "Resolve CRITICAL risks before proceeding",
+        };
+    }
+    if (assessment.needs_human_review) {
+        return {
+            stage: "confirmation",
+            status: "pending",
+            message: "Human review required for HIGH risks",
+            next_action: "Confirm risk acceptance",
+        };
+    }
+    return {
+        stage: "complete",
+        status: "pass",
+        message: "All checks passed",
+    };
+}

package/dist/knowledge/progress-context.d.ts

@@ -0,0 +1,123 @@
+import { type ProgressScene, type ProgressBuiltinPermissionEntry, type ProgressPhase } from "./progress-ledger.js";
+import { type ProgressPuzzle, type ProgressPuzzleCompleteness } from "./progress-puzzle.js";
+import { type ProgressRiskAssessment, type ProgressRiskRule, type ProgressStakeholder } from "./progress-risk.js";
+import { type ProgressSemanticToSchemaRule } from "./progress-translation.js";
+import { type ProgressTemplate } from "./progress-templates.js";
+import { PROGRESS_OPERATION_CHECKLIST, PROGRESS_CONFIRMATION_QUESTIONS, type ProgressJsonForConfirm } from "./progress-confirm.js";
+export declare const PROGRESS_CONTEXT_VERSION = "1.0.0";
+export type ProgressInjectionMode = "initial_design" | "mid_progress_review" | "pre_advance" | "post_task_binding" | "stakeholder_review" | "apply_check";
+export type ProgressStakeholderPerspective = ProgressStakeholder | "system";
+export interface ProgressContextBundle {
+    version: string;
+    mode: ProgressInjectionMode;
+    stakeholder_perspective?: ProgressStakeholderPerspective;
+    matched_scene?: ProgressScene;
+    matched_template?: ProgressTemplate;
+    matched_pattern?: ProgressSemanticToSchemaRule;
+    puzzle_state?: ProgressPuzzle;
+    puzzle_completeness?: ProgressPuzzleCompleteness;
+    relevant_risks: ProgressRiskRule[];
+    risk_assessment?: ProgressRiskAssessment;
+    relevant_checklist: typeof PROGRESS_OPERATION_CHECKLIST;
+    relevant_questions: typeof PROGRESS_CONFIRMATION_QUESTIONS;
+    relevant_builtin_permissions: ProgressBuiltinPermissionEntry[];
+    cross_object_refs: ProgressCrossObjectRef[];
+    onchain_constraints: ProgressOnchainConstraint[];
+    rendering_hints: ProgressRenderingHints;
+}
+export interface ProgressCrossObjectRef {
+    object: "Machine" | "Order" | "Repository" | "Permission" | "Service" | "Passport" | "Payment" | "Allocation";
+    phase: ProgressPhase | "universal";
+    relationship: string;
+    description: string;
+}
+export interface ProgressOnchainConstraint {
+    name: string;
+    value: string | number;
+    description: string;
+    error_code?: string;
+}
+export interface ProgressRenderingHints {
+    include_puzzle_template: boolean;
+    include_risk_details: boolean;
+    include_questions: boolean;
+    include_immutability_warning: boolean;
+    include_admin_unhold_warning: boolean;
+    include_cross_object_refs: boolean;
+    include_terminal_node_note: boolean;
+    max_length: number;
+}
+export interface BuildProgressContextInput {
+    mode: ProgressInjectionMode;
+    intent?: string;
+    progress_json?: ProgressJsonForConfirm;
+    stakeholder?: ProgressStakeholderPerspective;
+    target_phase?: ProgressPhase;
+    target_industry?: string;
+    max_length?: number;
+    current_machine?: string;
+    machine_published?: boolean;
+    current_task?: string | null;
+    current_named_operator_count?: number;
+    current_context_repository_count?: number;
+    current_node?: string;
+    forward_already_accomplished?: boolean;
+    holder_address?: string | null;
+    signer?: string;
+    forward_named_operator?: string;
+    forward_permission_index?: number | null;
+    forward_has_guard?: boolean;
+    target_objects_types?: string[];
+}
+export declare function buildProgressContext(input: BuildProgressContextInput): ProgressContextBundle;
+export declare function buildPromptFromProgressContext(bundle: ProgressContextBundle): string;
+export declare function getProgressContextSummary(bundle: ProgressContextBundle): string;
+export declare function buildStakeholderContext(stakeholder: ProgressStakeholderPerspective, intent?: string, progress_json?: ProgressJsonForConfirm): ProgressContextBundle;
+export declare function quickValidateProgressJson(progress_json: ProgressJsonForConfirm, current_state?: {
+    machine_published?: boolean;
+    current_task?: string | null;
+    current_named_operator_count?: number;
+    current_context_repository_count?: number;
+}): {
+    ok: boolean;
+    violations: string[];
+};
+export declare function getProgressKnowledgeSnapshot(): {
+    version: {
+        ledger: string;
+        puzzle: string;
+        risk: string;
+        translation: string;
+        templates: string;
+        confirm: string;
+        context: string;
+    };
+    scenes_count: number;
+    builtin_permissions_count: number;
+    builtin_permissions: {
+        index: 220 | 221 | 222 | 223 | 224 | 225;
+        name: string;
+        sdk_exposed: boolean;
+    }[];
+    templates_count: number;
+    templates: {
+        id: string;
+        name: string;
+        description: string;
+        scenes: string[];
+    }[];
+    semantic_patterns_count: number;
+    schema_rules_count: number;
+    constraint_rules_count: number;
+    risk_rules_count: number;
+    checklist_count: number;
+    confirmation_questions_count: number;
+    cross_object_refs_count: number;
+    onchain_limits: {
+        max_named_operator_count: 60;
+        max_named_operator_address_count: 80;
+        max_context_repository_count: 30;
+    };
+    injection_modes: ProgressInjectionMode[];
+    stakeholders: ProgressStakeholderPerspective[];
+};