@hotmeshio/long-tail 0.10.10 → 0.10.13

package/build/api/scan-codes/execute.js

@@ -0,0 +1,372 @@
+"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.executeScanCode = executeScanCode;
+const scanCodeService = __importStar(require("../../services/scan-code"));
+const escalationService = __importStar(require("../../services/escalation"));
+const metadata_1 = require("../escalations/metadata");
+const create_1 = require("../escalations/create");
+const claim_1 = require("../escalations/claim");
+const helpers_1 = require("../escalations/helpers");
+const types_1 = require("../../types");
+/**
+ * Execute a raw scan code: parse → load the rule → walk its steps in order.
+ * The first step whose condition matches performs its verb and answers; a
+ * step that matches nothing falls through to the next. Every terminal state
+ * is a structured 200 outcome — the scan surface reports, it doesn't throw.
+ */
+async function executeScanCode(input, auth) {
+    try {
+        if (!input.code || typeof input.code !== 'string') {
+            return { status: 400, error: 'code is required' };
+        }
+        // 1. Parse against the configured schemes
+        const schemes = await scanCodeService.listScanSchemes();
+        const parseResult = scanCodeService.parseScanCode(input.code, schemes);
+        if (!parseResult.ok) {
+            const { reason, detail } = parseResult.failure;
+            const outcome = reason === 'unknown_version' || reason === 'scheme_disabled'
+                ? types_1.SCAN_OUTCOMES.UNCONFIGURED
+                : types_1.SCAN_OUTCOMES.INVALID_CODE;
+            return { status: 200, data: { outcome, error: detail } };
+        }
+        const { parsed, scheme } = parseResult;
+        // 2. Load the rule for this category
+        const rule = await scanCodeService.getScanRule(parsed.version, parsed.category);
+        if (!rule || !rule.enabled) {
+            return {
+                status: 200,
+                data: {
+                    outcome: types_1.SCAN_OUTCOMES.UNCONFIGURED,
+                    parsed,
+                    error: `no scan rule configured for ${parsed.version}:${parsed.category}`,
+                },
+            };
+        }
+        // 3. Walk the steps — first condition match wins
+        const ctx = {
+            scheme, rule, parsed, scannedAt: new Date().toISOString(), auth,
+        };
+        for (let i = 0; i < rule.steps.length; i++) {
+            const result = await executeStep(rule.steps[i], i, ctx);
+            if (result)
+                return decorate(result, ctx, i);
+        }
+        // 4. Nothing matched — the fallback screen is the answer
+        return {
+            status: 200,
+            data: decorateData({ outcome: types_1.SCAN_OUTCOMES.NO_MATCH_FALLBACK, fallback: rule.fallback }, ctx),
+        };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/** Stamp rule identity + parsed code onto a step result. */
+function decorate(result, ctx, stepIndex) {
+    if (result.data && typeof result.data === 'object' && 'outcome' in result.data) {
+        result.data = { ...decorateData(result.data, ctx), stepIndex };
+    }
+    return result;
+}
+function decorateData(data, ctx) {
+    return {
+        ...data,
+        parsed: ctx.parsed,
+        rule: {
+            schemeVersion: ctx.rule.scheme_version,
+            category: ctx.rule.category,
+            name: ctx.rule.name,
+        },
+    };
+}
+/**
+ * Execute one step. Returns null when the step's condition matched nothing
+ * (fall through) and an LTApiResult for every terminal outcome.
+ */
+async function executeStep(step, index, ctx) {
+    // Confirm steps and read verbs only locate — mutation happens after the
+    // user confirms, through the standard per-id endpoints.
+    if (step.confirm || step.verb === types_1.SCAN_VERBS.SHOW_DETAIL || step.verb === types_1.SCAN_VERBS.SHOW_LIST) {
+        return locateStep(step, ctx);
+    }
+    switch (step.verb) {
+        case types_1.SCAN_VERBS.CLAIM:
+        case types_1.SCAN_VERBS.CLAIM_SHOW_DETAIL:
+            return claimStep(step, ctx);
+        case types_1.SCAN_VERBS.RESOLVE:
+            return resolveStep(step, ctx);
+        case types_1.SCAN_VERBS.ESCALATE:
+            return escalateStep(step, ctx);
+        case types_1.SCAN_VERBS.RELEASE:
+            return releaseStep(step, ctx);
+        case types_1.SCAN_VERBS.CANCEL:
+            return cancelStep(step, ctx);
+        default:
+            throw new Error(`unknown scan verb "${step.verb}"`);
+    }
+}
+// ── Shared pieces ──────────────────────────────────────────────────────────
+function targetFilter(step, ctx) {
+    return { [ctx.scheme.target_facet]: ctx.parsed.target, ...(step.query?.facets ?? {}) };
+}
+function templateContext(ctx) {
+    return { target: ctx.parsed.target, category: ctx.parsed.category, scannedAt: ctx.scannedAt };
+}
+function provenance(ctx) {
+    return {
+        [types_1.SCAN_PROVENANCE_KEYS.SCHEME]: ctx.scheme.version,
+        [types_1.SCAN_PROVENANCE_KEYS.CATEGORY]: ctx.parsed.category,
+        [types_1.SCAN_PROVENANCE_KEYS.ACTION_NAME]: ctx.rule.name,
+        [types_1.SCAN_PROVENANCE_KEYS.SCANNED_AT]: ctx.scannedAt,
+    };
+}
+function executed(escalation, step) {
+    return { status: 200, data: { outcome: types_1.SCAN_OUTCOMES.EXECUTED, verb: step.verb, escalation } };
+}
+// ── Locate (show-detail, show-list, confirm phase 1) ───────────────────────
+async function locateStep(step, ctx) {
+    const scope = await (0, helpers_1.getEscalationReadScope)(ctx.auth.userId);
+    const availability = step.query?.availability ?? types_1.SCAN_AVAILABILITY.ANY;
+    const status = step.query?.status ?? 'pending';
+    const wantMany = step.verb === types_1.SCAN_VERBS.SHOW_LIST
+        || step.cardinality === types_1.SCAN_CARDINALITY.MANY;
+    const limit = wantMany ? 50 : 2;
+    const facets = targetFilter(step, ctx);
+    let escalations;
+    let total;
+    if (availability === types_1.SCAN_AVAILABILITY.MINE) {
+        // "mine" = assigned to the caller; self-scope roles qualify because the
+        // assigned_to predicate satisfies their visibility branch.
+        const readable = [...scope.allRoles, ...scope.selfRoles];
+        const roles = (0, metadata_1.restrictScopeRoles)(readable, scope.global, step.query?.roles);
+        if (roles !== null && roles.length === 0)
+            return null;
+        const result = await escalationService.listEscalations({
+            metadata: facets,
+            status,
+            assigned_to: ctx.auth.userId,
+            visibleRoles: roles ?? undefined,
+            limit,
+        });
+        escalations = result.escalations;
+        total = result.total;
+    }
+    else {
+        const roles = (0, metadata_1.restrictScopeRoles)(scope.allRoles, scope.global, step.query?.roles);
+        if (roles !== null && roles.length === 0)
+            return null;
+        const result = await escalationService.searchByFacets({
+            roles: roles ?? undefined,
+            facets,
+            status,
+            available: availability === types_1.SCAN_AVAILABILITY.AVAILABLE
+                ? true
+                : availability === types_1.SCAN_AVAILABILITY.CLAIMED ? false : undefined,
+            limit,
+        });
+        escalations = result.escalations;
+        total = result.total;
+    }
+    if (escalations.length === 0)
+        return null;
+    if (step.confirm) {
+        const target = escalations[0];
+        const interpolated = step.params
+            ? scanCodeService.interpolateScanTemplate(step.params, templateContext(ctx))
+            : undefined;
+        return {
+            status: 200,
+            data: {
+                outcome: types_1.SCAN_OUTCOMES.CONFIRM_REQUIRED,
+                verb: step.verb,
+                escalation: target,
+                pendingAction: {
+                    escalationId: target.id,
+                    verb: step.verb,
+                    prompt: step.confirm.prompt,
+                    params: interpolated,
+                },
+            },
+        };
+    }
+    if (wantMany) {
+        return {
+            status: 200,
+            data: {
+                outcome: types_1.SCAN_OUTCOMES.MATCHED_LIST,
+                verb: step.verb,
+                escalations,
+                total,
+                listQuery: {
+                    ...step.query,
+                    targetFacet: ctx.scheme.target_facet,
+                    target: ctx.parsed.target,
+                },
+            },
+        };
+    }
+    return executed(escalations[0], step);
+}
+// ── Mutating verbs — each a single atomic operation under the caller's RBAC ─
+async function claimStep(step, ctx) {
+    const result = await (0, metadata_1.claimByMetadata)({
+        key: ctx.scheme.target_facet,
+        value: ctx.parsed.target,
+        durationMinutes: step.params?.durationMinutes,
+        metadata: { ...interpolatedMetadata(step, ctx), ...provenance(ctx) },
+        restrictRoles: step.query?.roles,
+    }, ctx.auth);
+    if (result.status === 404)
+        return null;
+    if (result.status === 403)
+        return forbidden(result.error);
+    if (result.status !== 200)
+        return result;
+    return executed(result.data.escalation, step);
+}
+async function resolveStep(step, ctx) {
+    const result = await (0, metadata_1.resolveByMetadata)({
+        key: ctx.scheme.target_facet,
+        value: ctx.parsed.target,
+        resolverPayload: scanCodeService.interpolateScanTemplate(step.params?.resolverPayload ?? {}, templateContext(ctx)),
+        metadata: { ...interpolatedMetadata(step, ctx), ...provenance(ctx) },
+        restrictRoles: step.query?.roles,
+        extraFacets: step.query?.facets,
+    }, ctx.auth);
+    if (result.status === 404)
+        return null;
+    if (result.status === 403)
+        return forbidden(result.error);
+    if (result.status === 409)
+        return conflict(result.error);
+    if (result.status !== 200)
+        return result;
+    const escalation = result.data.escalation
+        ?? (result.data.escalationId ? { id: result.data.escalationId } : undefined);
+    return executed(escalation, step);
+}
+async function escalateStep(step, ctx) {
+    // Close the located escalation first when configured — the close doubles as
+    // the condition check AND the double-scan guard (second scan finds nothing
+    // to close and falls through).
+    if (step.params?.closeCurrent === 'resolve') {
+        const closed = await resolveStep({ ...step, params: { ...step.params, resolverPayload: step.params?.resolverPayload ?? {} } }, ctx);
+        if (closed === null)
+            return null;
+        if (closed.data?.outcome !== types_1.SCAN_OUTCOMES.EXECUTED)
+            return closed;
+    }
+    else if (step.params?.closeCurrent === 'cancel') {
+        const cancelled = await cancelStep(step, ctx);
+        if (cancelled === null)
+            return null;
+        if (cancelled.data?.outcome !== types_1.SCAN_OUTCOMES.EXECUTED)
+            return cancelled;
+    }
+    const created = await (0, create_1.createEscalation)({
+        type: step.params?.escalationType ?? 'scan',
+        role: step.params.targetRole,
+        description: step.params?.description ?? ctx.rule.name,
+        metadata: {
+            [ctx.scheme.target_facet]: ctx.parsed.target,
+            ...interpolatedMetadata(step, ctx),
+            ...provenance(ctx),
+        },
+    }, ctx.auth);
+    if (created.status === 403)
+        return forbidden(created.error);
+    if (created.status !== 201)
+        return created;
+    return executed(created.data, step);
+}
+async function releaseStep(step, ctx) {
+    // Locate the caller's own claim; release-by-id re-asserts the assignee
+    // inside the SDK, so a lost race resolves to 409, never a foreign release.
+    const scope = await (0, helpers_1.getEscalationReadScope)(ctx.auth.userId);
+    const readable = [...scope.allRoles, ...scope.selfRoles];
+    const roles = (0, metadata_1.restrictScopeRoles)(readable, scope.global, step.query?.roles);
+    if (roles !== null && roles.length === 0)
+        return null;
+    const { escalations } = await escalationService.listEscalations({
+        metadata: targetFilter(step, ctx),
+        status: 'pending',
+        assigned_to: ctx.auth.userId,
+        visibleRoles: roles ?? undefined,
+        limit: 1,
+    });
+    if (escalations.length === 0)
+        return null;
+    const result = await (0, claim_1.releaseEscalation)({ id: escalations[0].id }, ctx.auth);
+    if (result.status === 403)
+        return forbidden(result.error);
+    if (result.status === 409)
+        return conflict(result.error);
+    if (result.status !== 200)
+        return result;
+    return executed(result.data.escalation, step);
+}
+async function cancelStep(step, ctx) {
+    // Claim-as-lock: the atomic claim pins the row to this caller (or extends
+    // their claim), serializing concurrent double-scans before the cancel.
+    const claimed = await (0, metadata_1.claimByMetadata)({
+        key: ctx.scheme.target_facet,
+        value: ctx.parsed.target,
+        metadata: provenance(ctx),
+        restrictRoles: step.query?.roles,
+    }, ctx.auth);
+    if (claimed.status === 404)
+        return null;
+    if (claimed.status === 403)
+        return forbidden(claimed.error);
+    if (claimed.status !== 200)
+        return claimed;
+    const cancelled = await escalationService.cancelEscalation(claimed.data.escalation.id);
+    if (!cancelled)
+        return conflict('Escalation is not cancellable (already terminal)');
+    return executed(cancelled, step);
+}
+// ── Small result helpers ───────────────────────────────────────────────────
+function interpolatedMetadata(step, ctx) {
+    return step.params?.metadata
+        ? scanCodeService.interpolateScanTemplate(step.params.metadata, templateContext(ctx))
+        : {};
+}
+function forbidden(error) {
+    return { status: 200, data: { outcome: types_1.SCAN_OUTCOMES.FORBIDDEN, error } };
+}
+function conflict(error) {
+    return { status: 200, data: { outcome: types_1.SCAN_OUTCOMES.CONFLICT, error } };
+}

package/build/api/scan-codes/index.d.ts

@@ -0,0 +1,2 @@
+export { executeScanCode } from './execute';
+export { listScanSchemes, getScanScheme, upsertScanScheme, deleteScanScheme, listScanRules, getScanRule, upsertScanRule, deleteScanRule, } from './config';

package/build/api/scan-codes/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteScanRule = exports.upsertScanRule = exports.getScanRule = exports.listScanRules = exports.deleteScanScheme = exports.upsertScanScheme = exports.getScanScheme = exports.listScanSchemes = exports.executeScanCode = void 0;
+var execute_1 = require("./execute");
+Object.defineProperty(exports, "executeScanCode", { enumerable: true, get: function () { return execute_1.executeScanCode; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "listScanSchemes", { enumerable: true, get: function () { return config_1.listScanSchemes; } });
+Object.defineProperty(exports, "getScanScheme", { enumerable: true, get: function () { return config_1.getScanScheme; } });
+Object.defineProperty(exports, "upsertScanScheme", { enumerable: true, get: function () { return config_1.upsertScanScheme; } });
+Object.defineProperty(exports, "deleteScanScheme", { enumerable: true, get: function () { return config_1.deleteScanScheme; } });
+Object.defineProperty(exports, "listScanRules", { enumerable: true, get: function () { return config_1.listScanRules; } });
+Object.defineProperty(exports, "getScanRule", { enumerable: true, get: function () { return config_1.getScanRule; } });
+Object.defineProperty(exports, "upsertScanRule", { enumerable: true, get: function () { return config_1.upsertScanRule; } });
+Object.defineProperty(exports, "deleteScanRule", { enumerable: true, get: function () { return config_1.deleteScanRule; } });

package/build/lib/db/schemas/025_ops_home_default.sql

@@ -0,0 +1,11 @@
+-- Migration 025: Home Pace Board default segment
+--
+-- ops_home_default marks the role whose sequence leads the HOME page's Pace
+-- Board. The board's full view lives on /operations; the home embed shows one
+-- segment, and this flag lets an operator pick which one — a subordinate
+-- setting under ops_visible on Role Detail. Single-holder: setting it on one
+-- role clears it everywhere else in the same atomic statement. When no role
+-- carries it, the home board falls back to the primary (first) segment.
+
+ALTER TABLE lt_roles
+  ADD COLUMN IF NOT EXISTS ops_home_default BOOLEAN NOT NULL DEFAULT false;

package/build/lib/db/schemas/026_scan_codes.sql

@@ -0,0 +1,51 @@
+-- Migration 026: Scan-code schemes and rules
+--
+-- A scan code arrives from a physical input source (barcode scanner, RFID
+-- reader, manual entry) as a plain string encoding version:category:target.
+-- The leading digit (1-9) selects a SCHEME: which escalation metadata facet
+-- the target resolves against and how the string parses (delimited text or
+-- fixed-width digits). The two-digit category selects a RULE: an ordered
+-- list of condition/action steps evaluated against the escalation surface,
+-- plus a fallback screen when no step matches.
+--
+-- Rules are plain config consulted at execute time (like lt_config_workflows);
+-- nothing pins a historical rule, so there is no snapshot table. Provenance
+-- is stamped into escalation metadata by the execute path instead.
+
+CREATE TABLE IF NOT EXISTS lt_config_scan_schemes (
+  version       SMALLINT PRIMARY KEY CHECK (version BETWEEN 1 AND 9),
+  name          TEXT NOT NULL,
+  description   TEXT,
+  target_facet  TEXT NOT NULL,
+  encoding      TEXT NOT NULL DEFAULT 'fixed'
+                  CHECK (encoding IN ('fixed', 'delimited')),
+  delimiter     TEXT NOT NULL DEFAULT ':',
+  target_length SMALLINT,
+  enabled       BOOLEAN NOT NULL DEFAULT TRUE,
+  created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  -- fixed-width parsing needs to know where the target ends
+  CONSTRAINT chk_scan_scheme_fixed_length
+    CHECK (encoding <> 'fixed' OR target_length IS NOT NULL)
+);
+
+CREATE OR REPLACE TRIGGER trg_lt_config_scan_schemes_updated_at
+  BEFORE UPDATE ON lt_config_scan_schemes
+  FOR EACH ROW EXECUTE FUNCTION lt_set_updated_at();
+
+CREATE TABLE IF NOT EXISTS lt_config_scan_actions (
+  scheme_version SMALLINT NOT NULL
+                   REFERENCES lt_config_scan_schemes(version) ON DELETE CASCADE,
+  category       TEXT NOT NULL CHECK (category ~ '^[0-9]{2}$'),
+  name           TEXT NOT NULL,
+  steps          JSONB NOT NULL DEFAULT '[]',
+  fallback       JSONB NOT NULL DEFAULT '{}',
+  enabled        BOOLEAN NOT NULL DEFAULT TRUE,
+  created_at     TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at     TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  PRIMARY KEY (scheme_version, category)
+);
+
+CREATE OR REPLACE TRIGGER trg_lt_config_scan_actions_updated_at
+  BEFORE UPDATE ON lt_config_scan_actions
+  FOR EACH ROW EXECUTE FUNCTION lt_set_updated_at();

package/build/lib/db/schemas/027_scan_codes_reindex.sql

@@ -0,0 +1,23 @@
+-- Migration 027: Scan-code numbering inversion
+--
+-- The scheme index moves to the leading TWO digits (10-99) and the category
+-- (rule) index to a single digit (0-9): a code now reads ##:#:target. Two
+-- reasons: a code never starts with a leading zero (some scanners choke on it),
+-- and the top-level "named item" you organize by (the scheme) gets the wider
+-- 90-slot space while each scheme's rules stay a small 0-9 set. The indices are
+-- assigned automatically; operators name entries, never pick numbers.
+--
+-- Old rows (single-digit version, two-digit category) cannot satisfy the new
+-- checks and their codes no longer parse, so the config is cleared and re-seeded.
+
+TRUNCATE lt_config_scan_actions, lt_config_scan_schemes;
+
+ALTER TABLE lt_config_scan_schemes
+  DROP CONSTRAINT IF EXISTS lt_config_scan_schemes_version_check;
+ALTER TABLE lt_config_scan_schemes
+  ADD CONSTRAINT lt_config_scan_schemes_version_check CHECK (version BETWEEN 10 AND 99);
+
+ALTER TABLE lt_config_scan_actions
+  DROP CONSTRAINT IF EXISTS lt_config_scan_actions_category_check;
+ALTER TABLE lt_config_scan_actions
+  ADD CONSTRAINT lt_config_scan_actions_category_check CHECK (category ~ '^[0-9]$');

package/build/lib/events/system-events.js

@@ -44,6 +44,10 @@ function mapSystemEvent(event) {
             escalationId: row.id || segments[2],
             originId: row.origin_id || event.origin_id || undefined,
             status: ESCALATION_STATUS_BY_VERB[verb] ?? verb,
+            // Assignment provenance rides the SystemEvent envelope, NOT the row (it is
+            // not a column). Forward it so a consumer can tell a born-assigned,
+            // system-directed hand-off (`claimed` with true) from an interactive claim.
+            assignedAtCreation: event.assigned_at_creation,
             data: row,
             timestamp: event.ts,
         };

package/build/modules/features.d.ts

@@ -12,6 +12,23 @@ export interface FeatureFlags {
      * Default: true. Set `features.dbMaintenance: false` in start config to hide it.
      */
     dbMaintenance: boolean;
+    /**
+     * The Pace Board is readable by every authenticated user: station metrics
+     * (aggregate queue-shape counts and trends — never item content) span all
+     * roles for any login, and the board leads everyone's home page. Default:
+     * true. Set `features.publicPaceBoard: false` to scope metrics back to role
+     * membership — the right call for deployments that provision external
+     * one-time accounts (e.g. a customer resolving a single form).
+     */
+    publicPaceBoard: boolean;
+    /**
+     * Scan-code input on every login: the header scan affordance, the panel,
+     * and the global keyboard-wedge capture. Opt-IN: default false — a
+     * deployment turns it on with `features.scanCodes: true` when scanners are
+     * part of the floor workflow. The scan-code execute/config API stays
+     * available either way (the flag gates the dashboard surface).
+     */
+    scanCodes: boolean;
 }
 /** Merge a partial set of flags from the start config. Unspecified flags keep their default. */
 export declare function configureFeatureFlags(patch?: Partial<FeatureFlags>): void;

package/build/modules/features.js

@@ -4,6 +4,8 @@ exports.configureFeatureFlags = configureFeatureFlags;
 exports.getFeatureFlags = getFeatureFlags;
 const DEFAULT_FLAGS = {
     dbMaintenance: true,
+    publicPaceBoard: true,
+    scanCodes: false,
 };
 let flags = { ...DEFAULT_FLAGS };
 /** Merge a partial set of flags from the start config. Unspecified flags keep their default. */

package/build/routes/escalations/list.js

@@ -92,6 +92,7 @@ function registerListRoutes(router) {
             type: req.query.type,
             subtype: req.query.subtype,
             assigned_to: req.query.assigned_to,
+            parent_id: req.query.parent_id,
             claimed: req.query.claimed === 'true',
             priority: req.query.priority ? parseInt(req.query.priority, 10) : undefined,
             limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,

package/build/routes/index.js

@@ -36,6 +36,7 @@ const agents_1 = __importDefault(require("./agents"));
 const capabilities_1 = __importDefault(require("./capabilities"));
 const topics_1 = __importDefault(require("./topics"));
 const nats_credentials_1 = __importDefault(require("./nats-credentials"));
+const scan_codes_1 = __importDefault(require("./scan-codes"));
 const router = (0, express_1.Router)();
 // Public routes (no auth required — they handle their own auth)
 router.use('/auth', auth_2.default);
@@ -72,6 +73,7 @@ router.use('/knowledge', knowledge_1.default);
 router.use('/agents', agents_1.default);
 router.use('/capabilities', capabilities_1.default);
 router.use('/topics', topics_1.default);
+router.use('/scan-codes', scan_codes_1.default);
 const overview_1 = __importDefault(require("./overview"));
 router.use('/overview', overview_1.default);
 const diagnostics_1 = __importDefault(require("./diagnostics"));

package/build/routes/scan-codes.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;