@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/demand-confirm.js

@@ -0,0 +1,206 @@
+import { MAX_REWARD_COUNT, MAX_GUARD_COUNT_DEMAND, MAX_DESCRIPTION_LENGTH, MAX_LONG_NAME_LENGTH, } from "@wowok/wowok";
+const MAX_FEEDBACK_COUNT = 20;
+function checkDescription(input) {
+    const len = input.description?.length ?? 0;
+    const passed = len > 0 && len <= MAX_DESCRIPTION_LENGTH;
+    return {
+        id: "C-DEM-01",
+        severity: passed ? "info" : (len === 0 ? "warn" : "block"),
+        title: `description non-empty and within MAX_DESCRIPTION_LENGTH (${MAX_DESCRIPTION_LENGTH} chars)`,
+        description: "description is a REQUIRED field. Move contract validates via common::DESCRIPTION (demand.move:157,177). " +
+            "Empty string is technically rejected by common::DESCRIPTION only if NAME_ALLOW_EMPTY is not used; the new_imp " +
+            "path uses common::DESCRIPTION which allows empty but enforces the 4000-char limit. Non-empty descriptions are " +
+            "strongly recommended for Demand discoverability.",
+        passed,
+        evidence: input.description === undefined ? "undefined" : `length=${len}, limit=${MAX_DESCRIPTION_LENGTH}`,
+        fix_hint: passed ? undefined : `Provide a description of 1..${MAX_DESCRIPTION_LENGTH} characters.`,
+    };
+}
+function checkLocation(input) {
+    const len = input.location?.length ?? 0;
+    const passed = len <= MAX_LONG_NAME_LENGTH;
+    return {
+        id: "C-DEM-02",
+        severity: passed ? "info" : "block",
+        title: `location within MAX_LONG_NAME_LENGTH (${MAX_LONG_NAME_LENGTH} chars)`,
+        description: "location is set via location_set_imp (demand.move:179-182) which validates via common::LONG_NAME. " +
+            "Move aborts with E_LONG_NAME_LENGTH_EXCEEDED (11) on overflow. Empty location (\"\") is valid — new_imp " +
+            "initializes location to empty string. Use location_set to update after creation.",
+        passed,
+        evidence: input.location === undefined ? "undefined" : `length=${len}, limit=${MAX_LONG_NAME_LENGTH}`,
+        fix_hint: passed ? undefined : `Trim location to ≤ ${MAX_LONG_NAME_LENGTH} characters.`,
+    };
+}
+function checkRewards(input) {
+    const count = input.rewards?.length ?? 0;
+    const passed = count <= MAX_REWARD_COUNT;
+    return {
+        id: "C-DEM-03",
+        severity: passed ? "info" : "block",
+        title: `rewards count within MAX_REWARD_COUNT (${MAX_REWARD_COUNT})`,
+        description: "Each reward_add_imp (demand.move:184-191) checks `vector::length(&self.rewards) < MAX_REWARD_COUNT` " +
+            "before pushing (after de-duplication). Move aborts with E_MAX_REWARD_COUNT_EXCEEDED (1) on overflow. " +
+            "Rewards are affiliated via the Registrar — adding/removing triggers affiliation/disaffiliation.",
+        passed,
+        evidence: `count=${count}, limit=${MAX_REWARD_COUNT}`,
+        fix_hint: passed ? undefined : `Remove rewards before adding new ones. Limit=${MAX_REWARD_COUNT}.`,
+    };
+}
+function checkGuards(input) {
+    const count = input.guards?.length ?? 0;
+    const passed = count <= MAX_GUARD_COUNT_DEMAND;
+    return {
+        id: "C-DEM-04",
+        severity: passed ? "info" : "block",
+        title: `guards count within MAX_GUARD_COUNT_DEMAND (${MAX_GUARD_COUNT_DEMAND})`,
+        description: "Each guard_add_imp (demand.move:213-242) checks `vector::length(&self.guards) < MAX_GUARD_COUNT` " +
+            "before pushing (after duplicate check — duplicates update service_identifier in place). " +
+            "Move aborts with E_MAX_GUARD_COUNT_EXCEEDED (2) on overflow. Guards are affiliated via the Registrar.",
+        passed,
+        evidence: `count=${count}, limit=${MAX_GUARD_COUNT_DEMAND}`,
+        fix_hint: passed ? undefined : `Remove guards before adding new ones. Limit=${MAX_GUARD_COUNT_DEMAND}.`,
+    };
+}
+function checkFeedback(input) {
+    const count = input.feedback?.length ?? 0;
+    const passed = count <= MAX_FEEDBACK_COUNT;
+    return {
+        id: "C-DEM-05",
+        severity: passed ? "info" : "block",
+        title: `feedback batch count within MAX_FEEDBACK_COUNT (${MAX_FEEDBACK_COUNT})`,
+        description: "Move feedback (demand.move:352) updates ONE presenter per call — feedback_imp writes to a single " +
+            "ServiceInfo record. The SDK batches multiple feedback calls and caps the batch at MAX_FEEDBACK_COUNT=" +
+            `${MAX_FEEDBACK_COUNT} (SDK-only limit, NOT in onchain-constants.ts). Exceeding the SDK batch limit is ` +
+            "rejected before transaction building. Each feedback string is validated by common::DESCRIPTION (4000 chars).",
+        passed,
+        evidence: `count=${count}, limit=${MAX_FEEDBACK_COUNT}`,
+        fix_hint: passed ? undefined : `Split feedback into batches of ≤ ${MAX_FEEDBACK_COUNT} entries.`,
+    };
+}
+function checkServiceIdentifier(input) {
+    const sid = input.service_identifier;
+    if (sid === null || sid === undefined) {
+        return {
+            id: "C-DEM-06",
+            severity: "info",
+            title: "service_identifier is null/undefined → Option::none (use supplied service address)",
+            description: "When service_identifier is None, guard_add_imp stores Option::none in ServiceGuard. At present_with_passport " +
+                "time, present_with_passport_imp uses the service parameter (or Option::none for plain present_with_passport). " +
+                "Use None when the Demand does not need to route presentations through a specific Service submission.",
+            passed: true,
+            evidence: "null/undefined → Option::none",
+        };
+    }
+    const isU8 = typeof sid === "number" && Number.isInteger(sid) && sid >= 0 && sid <= 255;
+    return {
+        id: "C-DEM-06",
+        severity: isU8 ? "info" : "block",
+        title: "service_identifier is a valid u8 (0-255) when provided",
+        description: "When provided, service_identifier must be a u8 index into the Guard's submission registry. " +
+            "guard_add_imp (demand.move:218-222) calls guard::get_submission_object_type(guard, *i) and " +
+            "common::assert_service_object_type(t) — the submission at that index MUST exist and have type " +
+            "ObjectType::Service. At present_with_passport time, the submission address is extracted from the Passport " +
+            "via passport::submission_get(passport, &g, *service_identifier).",
+        passed: isU8,
+        evidence: `service_identifier=${sid}`,
+        fix_hint: isU8 ? undefined : "Provide an integer in [0, 255] that indexes a Service-typed submission in the Guard.",
+    };
+}
+function checkByGuard(input) {
+    const byGuard = input.by_guard;
+    if (byGuard === null || byGuard === undefined) {
+        return {
+            id: "C-DEM-07",
+            severity: "info",
+            title: "by_guard is null → use plain present (requires empty guards vector)",
+            description: "When by_guard is None, the caller uses plain present (demand.move:100) which asserts " +
+                "`vector::is_empty(&self.guards)` — aborts with E_NEED_PASSPORT (3) if guards exist. Use this path " +
+                "for open Demands (no guards).",
+            passed: true,
+            evidence: "null/undefined → plain present path",
+        };
+    }
+    if (input.guards === undefined) {
+        return {
+            id: "C-DEM-07",
+            severity: "info",
+            title: "by_guard provided (cannot verify membership — guards list not supplied)",
+            description: "present_with_passport_imp (demand.move:110-129) iterates the guards vector looking for a matching " +
+                "guard address. If not found, it aborts with E_GUARD_NOT_FOUND (4). The caller must ensure by_guard " +
+                "is in Demand.guards — this check could not verify because the guards list was not supplied.",
+            passed: true,
+            evidence: `by_guard=${byGuard.substring(0, 10)}... (guards list not supplied)`,
+            fix_hint: "Pass input.guards to enable membership verification.",
+        };
+    }
+    const isInGuards = input.guards.includes(byGuard);
+    return {
+        id: "C-DEM-07",
+        severity: isInGuards ? "info" : "block",
+        title: "by_guard exists in Demand.guards (when specified)",
+        description: "When by_guard is specified, present_with_passport_imp (demand.move:110-129) iterates the guards vector " +
+            "looking for a matching guard address. If not found, it aborts with E_GUARD_NOT_FOUND (4). The caller " +
+            "MUST ensure by_guard was previously added via guard_add.",
+        passed: isInGuards,
+        evidence: `by_guard=${byGuard.substring(0, 10)}..., in guards=${isInGuards}`,
+        fix_hint: isInGuards ? undefined : "Call guard_add(permission, guard, service_identifier) first.",
+    };
+}
+function checkPermissionSetAvailable(input) {
+    const available = input.permission_set_available !== false;
+    return {
+        id: "C-DEM-08",
+        severity: available ? "info" : "warn",
+        title: "permission_set available via CallPermission.apply (DE-D-2=A)",
+        description: "The Move permission_set function (demand.move:286) is exposed in the SDK via the CallPermission.apply " +
+            "mechanism (DE-D-2=A). It calls permission::assert_owner(old) and registrar::affiliation_change to migrate " +
+            "the affiliation. Permission indices for Demand (demand.move:20): 400=DEMAND_NEW, 401=DEMAND_DESCRIPTION, " +
+            "402=DEMAND_LOCATION, 404=DEMAND_GUARD, 405=DEMAND_REWARD, 406=DEMAND_FEEDBACK, 407=DEMAND_OWNER_RECEIVE, " +
+            "408=DEMAND_UM. This is an info check — it confirms the capability is available, not a creation prerequisite.",
+        passed: available,
+        evidence: available ? "exposed via CallPermission.apply" : "not available (regression)",
+        fix_hint: available ? undefined : "Restore the CallPermission.apply path for permission_set.",
+    };
+}
+export function preCheckDemandCreation(input) {
+    return [
+        checkDescription(input),
+        checkLocation(input),
+        checkRewards(input),
+        checkGuards(input),
+        checkFeedback(input),
+        checkServiceIdentifier(input),
+        checkByGuard(input),
+        checkPermissionSetAvailable(input),
+    ];
+}
+export function canCreateDemand(input) {
+    const items = preCheckDemandCreation(input);
+    return {
+        canCreate: items.every(i => i.severity !== "block" || i.passed),
+        blockers: items.filter(i => i.severity === "block" && !i.passed),
+        warnings: items.filter(i => i.severity === "warn" && !i.passed),
+        info: items.filter(i => i.severity === "info"),
+    };
+}
+export function formatDemandCreationSummary(input) {
+    const { canCreate, blockers, warnings, info } = canCreateDemand(input);
+    const lines = [];
+    lines.push(canCreate ? "✓ Demand pre-check PASSED" : "✗ Demand pre-check FAILED");
+    lines.push("");
+    if (blockers.length > 0) {
+        lines.push("BLOCKERS (must fix before operation):");
+        blockers.forEach(b => lines.push(`  [${b.id}] ${b.title} — ${b.evidence ?? ""}`));
+        lines.push("");
+    }
+    if (warnings.length > 0) {
+        lines.push("WARNINGS (review recommended):");
+        warnings.forEach(w => lines.push(`  [${w.id}] ${w.title} — ${w.evidence ?? ""}`));
+        lines.push("");
+    }
+    if (info.length > 0) {
+        lines.push("INFO:");
+        info.forEach(i => lines.push(`  [${i.id}] ${i.title}`));
+    }
+    return lines.join("\n");
+}

package/dist/knowledge/demand-risk.d.ts

@@ -0,0 +1,30 @@
+export type DemandRiskLevel = "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "INFO";
+export type DemandRiskCategory = "structural" | "semantic" | "lifecycle" | "knowledge";
+export type DemandStakeholder = "creator" | "presenter" | "consumer" | "system";
+export interface DemandRisk {
+    id: string;
+    level: DemandRiskLevel;
+    category: DemandRiskCategory;
+    title: string;
+    description: string;
+    affected_stakeholders: DemandStakeholder[];
+    scenario: string;
+    mitigation: string;
+    evidence?: string;
+    related_move_error?: string;
+    auto_fixable: boolean;
+}
+export interface DemandRiskCheckContext {
+    reward_count?: number;
+    guard_count?: number;
+    feedback_count?: number;
+    using_present_without_passport?: boolean;
+    guards_non_empty?: boolean;
+    constants_synced?: boolean;
+}
+export declare const DEMAND_RISK_RULES: {
+    rule: DemandRisk;
+    check: (ctx: DemandRiskCheckContext) => DemandRisk | null;
+}[];
+export declare function checkDemandRisks(ctx: DemandRiskCheckContext): DemandRisk[];
+export declare function getDemandRiskById(id: string): DemandRisk | undefined;

package/dist/knowledge/demand-risk.js

@@ -0,0 +1,240 @@
+import { MAX_REWARD_COUNT, MAX_GUARD_COUNT_DEMAND, } from "@wowok/wowok";
+const MAX_FEEDBACK_COUNT = 20;
+const R_DEM_1_01 = {
+    rule: {
+        id: "R-DEM-01",
+        level: "HIGH",
+        category: "structural",
+        title: `rewards count exceeds MAX_REWARD_COUNT (${MAX_REWARD_COUNT})`,
+        description: `The 'rewards' vector is bounded by MAX_REWARD_COUNT=${MAX_REWARD_COUNT} (Move source: demand.move:21). ` +
+            `Exceeding this limit aborts with E_MAX_REWARD_COUNT_EXCEEDED (1). Each reward is affiliated via the Registrar, ` +
+            `so adding a reward also triggers registrar::affiliation. Use reward_remove/reward_clear to free slots before ` +
+            `adding new ones if the limit is reached.`,
+        affected_stakeholders: ["creator"],
+        scenario: "Caller calls reward_add when 20 rewards are already affiliated",
+        mitigation: "Track the current reward count. Before adding a new reward, call reward_remove or reward_clear to " +
+            "free a slot. Consider consolidating rewards into a single Reward object with multiple tiers if the " +
+            " Demand needs to offer more than 20 distinct reward paths.",
+        related_move_error: "E_MAX_REWARD_COUNT_EXCEEDED (1)",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (ctx.reward_count === undefined)
+            return null;
+        if (ctx.reward_count <= MAX_REWARD_COUNT)
+            return null;
+        return { ...R_DEM_1_01.rule, evidence: `reward_count=${ctx.reward_count}, limit=${MAX_REWARD_COUNT}` };
+    },
+};
+const R_DEM_1_02 = {
+    rule: {
+        id: "R-DEM-02",
+        level: "HIGH",
+        category: "structural",
+        title: `guards count exceeds MAX_GUARD_COUNT_DEMAND (${MAX_GUARD_COUNT_DEMAND})`,
+        description: `The 'guards' vector is bounded by MAX_GUARD_COUNT_DEMAND=${MAX_GUARD_COUNT_DEMAND} (Move source: demand.move:22). ` +
+            `Exceeding this limit aborts with E_MAX_GUARD_COUNT_EXCEEDED (2). Each guard carries an optional ` +
+            `service_identifier (u8) that routes present_with_passport submissions to a specific Service submission ` +
+            `extracted from the Passport. Adding a duplicate guard updates the service_identifier instead of pushing.`,
+        affected_stakeholders: ["creator", "presenter"],
+        scenario: "Caller calls guard_add when 20 guards are already affiliated and the address is new",
+        mitigation: "Track the current guard count. Before adding a new guard, call guard_remove or guard_clear. " +
+            "If updating an existing guard's service_identifier, call guard_add with the same address (it updates " +
+            "in place rather than pushing).",
+        related_move_error: "E_MAX_GUARD_COUNT_EXCEEDED (2)",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (ctx.guard_count === undefined)
+            return null;
+        if (ctx.guard_count <= MAX_GUARD_COUNT_DEMAND)
+            return null;
+        return { ...R_DEM_1_02.rule, evidence: `guard_count=${ctx.guard_count}, limit=${MAX_GUARD_COUNT_DEMAND}` };
+    },
+};
+const R_DEM_1_03 = {
+    rule: {
+        id: "R-DEM-03",
+        level: "MEDIUM",
+        category: "structural",
+        title: `feedback batch exceeds MAX_FEEDBACK_COUNT (${MAX_FEEDBACK_COUNT})`,
+        description: `The 'feedback' Move function (demand.move:352) updates ONE presenter per call (feedback_imp iterates ` +
+            `no vector). The SDK batches multiple feedback calls and caps the batch at MAX_FEEDBACK_COUNT=${MAX_FEEDBACK_COUNT} ` +
+            `(SDK-only limit, NOT in onchain-constants.ts — Move has no aggregate feedback-count check). Exceeding the ` +
+            `SDK batch limit causes the SDK to refuse the call before transaction building. Each feedback entry writes ` +
+            `a String (bounded by common::DESCRIPTION, 4000 chars) and an optional u8 acceptance_score to a presenter's ` +
+            `ServiceInfo record.`,
+        affected_stakeholders: ["creator"],
+        scenario: "Caller attempts to submit 21 feedback entries in a single SDK call",
+        mitigation: "Split the feedback batch into chunks of ≤ 20 entries. If the Demand has more than 20 presenters to " +
+            "give feedback on, submit multiple transactions. Consider whether bulk feedback is appropriate — " +
+            "individualized feedback per presenter is often more meaningful.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (ctx.feedback_count === undefined)
+            return null;
+        if (ctx.feedback_count <= MAX_FEEDBACK_COUNT)
+            return null;
+        return { ...R_DEM_1_03.rule, evidence: `feedback_count=${ctx.feedback_count}, limit=${MAX_FEEDBACK_COUNT}` };
+    },
+};
+const R_DEM_2_01 = {
+    rule: {
+        id: "R-DEM-04",
+        level: "HIGH",
+        category: "semantic",
+        title: "present called without passport when guards vector is non-empty",
+        description: "The Move present function (demand.move:100) asserts `vector::is_empty(&self.guards)` and aborts with " +
+            "E_NEED_PASSPORT (3) if the guards vector is non-empty. When guards exist, every presenter MUST go through " +
+            "present_with_passport (or present_service_with_passport), which routes through present_with_passport_imp. " +
+            "That function looks up the specified Guard in the guards vector, calls passport::result_for_guard to " +
+            "verify the Passport, and (if service_identifier is set) extracts the submission address from the Passport. " +
+            "Calling plain `present` on a guarded Demand always aborts — there is no fallback path.",
+        affected_stakeholders: ["presenter", "creator"],
+        scenario: "Demand has 2 guards; a presenter calls present() instead of present_with_passport()",
+        mitigation: "Before presenting, query the Demand's guards vector. If non-empty, use present_with_passport and " +
+            "supply a Guard + Passport. The Guard address must already be in the guards vector (otherwise " +
+            "E_GUARD_NOT_FOUND (4) aborts). If service_identifier is set on the matching guard, the submission " +
+            "address is extracted from the Passport — do not pass a separate service parameter.",
+        related_move_error: "E_NEED_PASSPORT (3)",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.using_present_without_passport)
+            return null;
+        if (!ctx.guards_non_empty)
+            return null;
+        return { ...R_DEM_2_01.rule, evidence: `guards_non_empty=true, using present (no passport)` };
+    },
+};
+const R_DEM_3_01 = {
+    rule: {
+        id: "R-DEM-05",
+        level: "INFO",
+        category: "lifecycle",
+        title: "um_set_imp Registrar dependency leak — RESOLVED (P-DEM-P1-1)",
+        description: "PREVIOUS RISK: um_set_imp (demand.move:139-147) previously set self.um to the new Contact address " +
+            "BEFORE disaffiliating the old um, causing the old Contact to retain a stale affiliation record in the " +
+            "Registrar. Affiliation_change was not called for the old um, leading to a Registrar dependency leak.\n\n" +
+            "FIX (P-DEM-P1-1): um_set_imp now disaffiliates the old um via registrar::disaffiliation BEFORE setting " +
+            "the new one. The new um is then affiliated via registrar::affiliation. This matches the pattern used " +
+            "by permission_set (which uses affiliation_change). um_none_imp also disaffiliates before clearing.\n\n" +
+            "This rule is retained for historical audit and to detect regressions.",
+        affected_stakeholders: ["creator", "system"],
+        scenario: "Future regression: someone reorders um_set_imp to set new before disaffiliating old",
+        mitigation: "Keep the disaffiliate-then-set ordering. The Move invariant: any path that mutates self.um MUST call " +
+            "registrar::disaffiliation on the old value before assigning a new one.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (ctx.constants_synced)
+            return null;
+        return { ...R_DEM_3_01.rule, evidence: "constants_synced=false (regression check)" };
+    },
+};
+const R_DEM_2_02 = {
+    rule: {
+        id: "R-DEM-06",
+        level: "INFO",
+        category: "semantic",
+        title: "guard_add_imp service_identifier type check skipped on early return — RESOLVED (P-DEM-P1-2)",
+        description: "PREVIOUS RISK: guard_add_imp (demand.move:213-242) previously had the service_identifier type check " +
+            "AFTER the early-return path that updates an existing guard's service_identifier. When a guard with " +
+            "the same address already existed, the function returned before validating the new service_identifier " +
+            "against guard::get_submission_object_type. This allowed setting an invalid service_identifier that " +
+            "would later fail at present_with_passport time with E_INVALID_SERVICE_OBJECT_TYPE (common.move:13).\n\n" +
+            "FIX (P-DEM-P1-2): The service_identifier type check now runs FIRST (demand.move:218-222), BEFORE the " +
+            "duplicate-detection loop. common::assert_service_object_type is called for any non-None service_identifier, " +
+            "ensuring both the insert and update paths validate the type.\n\n" +
+            "This rule is retained for historical audit and to detect regressions.",
+        affected_stakeholders: ["creator", "presenter"],
+        scenario: "Future regression: someone moves the type check back to after the duplicate-detection loop",
+        mitigation: "Keep the type check at the top of guard_add_imp. The Move invariant: any service_identifier provided " +
+            "to guard_add MUST be validated via guard::get_submission_object_type + common::assert_service_object_type " +
+            "BEFORE any mutation of the guards vector.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (ctx.constants_synced)
+            return null;
+        return { ...R_DEM_2_02.rule, evidence: "constants_synced=false (regression check)" };
+    },
+};
+const R_DEM_4_01 = {
+    rule: {
+        id: "R-DEM-07",
+        level: "INFO",
+        category: "knowledge",
+        title: "extractDemandInfo expects non-existent Move fields — RESOLVED (P-DEM-P1-3)",
+        description: "PREVIOUS RISK: extractDemandInfo in demand-matching.ts previously read fields (tags, maxPrice, " +
+            "scenario, minTrustScore, keywords) that do NOT exist on the Move Demand struct. The Move struct only " +
+            "has: description, location, rewards, guards, presenters, um, permission. This caused the matching " +
+            "engine to silently produce undefined values when fed raw on-chain query results.\n\n" +
+            "FIX (P-DEM-P1-3): extractDemandInfo now documents the caller-enrichment contract. Only `location` maps " +
+            "directly to the Move Demand struct; all other fields (tags, maxPrice, scenario, minTrustScore, keywords) " +
+            "MUST be injected by the caller before calling matchDemand. The caller is responsible for sourcing " +
+            "this data from Service tags, Reward objects, user input, or NLP on the description.\n\n" +
+            "This rule is retained for historical audit and to detect regressions.",
+        affected_stakeholders: ["system"],
+        scenario: "Future regression: someone removes the caller-enrichment contract docs from extractDemandInfo",
+        mitigation: "Keep the [caller-enriched] / [on-chain] annotations on DemandInfo fields. The matching engine must " +
+            "never query on-chain data directly — it is a pure scoring function over caller-injected data.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (ctx.constants_synced)
+            return null;
+        return { ...R_DEM_4_01.rule, evidence: "constants_synced=false (regression check)" };
+    },
+};
+const R_DEM_4_02 = {
+    rule: {
+        id: "R-DEM-08",
+        level: "INFO",
+        category: "knowledge",
+        title: "permission_set not exposed in SDK — RESOLVED (DE-D-2=A)",
+        description: "PREVIOUS GAP: The Move permission_set function (demand.move:286) was not exposed as a standalone " +
+            "function in the SDK's call/demand.ts. Callers could not change the Permission object bound to a Demand " +
+            "after creation.\n\n" +
+            "RESOLUTION (DE-D-2=A): permission_set is now exposed via the CallPermission.apply mechanism. The SDK " +
+            "wraps permission_set by routing it through CallPermission, which performs the assert_owner check on the " +
+            "old Permission and updates the Demand's bound permission. The Registrar's affiliation_change is called " +
+            "to migrate the affiliation from the old Permission to the new one.\n\n" +
+            "Permission indices for Demand (demand.move:20): 400=DEMAND_NEW, 401=DEMAND_DESCRIPTION, 402=DEMAND_LOCATION, " +
+            "404=DEMAND_GUARD, 405=DEMAND_REWARD, 406=DEMAND_FEEDBACK, 407=DEMAND_OWNER_RECEIVE, 408=DEMAND_UM.\n\n" +
+            "This rule is retained for historical audit and to detect regressions.",
+        affected_stakeholders: ["creator", "system"],
+        scenario: "Future regression: someone removes the CallPermission.apply path for permission_set",
+        mitigation: "Keep permission_set exposed via CallPermission.apply. The Move invariant: permission_set requires " +
+            "permission::assert_owner(old) and MUST call registrar::affiliation_change to migrate the affiliation.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (ctx.constants_synced)
+            return null;
+        return { ...R_DEM_4_02.rule, evidence: "constants_synced=false (regression check)" };
+    },
+};
+export const DEMAND_RISK_RULES = [
+    R_DEM_1_01,
+    R_DEM_1_02,
+    R_DEM_1_03,
+    R_DEM_2_01,
+    R_DEM_3_01,
+    R_DEM_2_02,
+    R_DEM_4_01,
+    R_DEM_4_02,
+];
+export function checkDemandRisks(ctx) {
+    const risks = [];
+    for (const rule of DEMAND_RISK_RULES) {
+        const r = rule.check(ctx);
+        if (r)
+            risks.push(r);
+    }
+    return risks;
+}
+export function getDemandRiskById(id) {
+    return DEMAND_RISK_RULES.find(r => r.rule.id === id)?.rule;
+}

package/dist/knowledge/demand-translation.d.ts

@@ -0,0 +1,55 @@
+export interface SemanticToDemandSchemaRule {
+    id: string;
+    pattern_name: string;
+    configuration_classification: "open" | "guarded" | "um_managed";
+    semantic_intent: string;
+    match_keywords: string[];
+    schema_elements: {
+        required_fields: string[];
+        optional_fields: string[];
+        presentation_path: "plain_present" | "present_with_passport" | "either";
+        um_recommendation: string;
+    };
+    constraints: string[];
+    example: Record<string, unknown>;
+}
+export declare const SEMANTIC_TO_DEMAND_SCHEMA_RULES: SemanticToDemandSchemaRule[];
+export interface DemandFieldTranslation {
+    field_name: string;
+    move_field?: string;
+    value_type: string;
+    semantic: string;
+    format_example: string;
+    validation_rules: string[];
+}
+export declare const DEMAND_FIELD_TRANSLATIONS: DemandFieldTranslation[];
+export interface DemandConstraintRule {
+    id: string;
+    name: string;
+    description: string;
+    validation_logic: string;
+    failure_message: string;
+    related_field: string;
+}
+export declare const DEMAND_CONSTRAINT_RULES: DemandConstraintRule[];
+export interface DemandExplainInput {
+    description?: string;
+    location?: string;
+    rewards?: string[];
+    guards?: {
+        guard: string;
+        service_identifier?: number | null;
+    }[];
+    um?: string | null;
+    permission?: string;
+}
+export interface DemandExplanation {
+    summary: string;
+    configuration_classification: string;
+    presentation_path: string;
+    binding_status: string;
+    size_status: string;
+    warnings: string[];
+    recommendations: string[];
+}
+export declare function explainDemand(input: DemandExplainInput): DemandExplanation;