@qnote/q-ai-note 1.0.13 → 1.0.14

package/dist/server/aserRuntimeStore.js

@@ -0,0 +1,826 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { v4 as uuidv4 } from 'uuid';
+function findIntentTaxonomy(project, task) {
+    const intent = project.intents.find((row) => String(row.id) === String(task.intent_id));
+    return String(intent?.taxonomy || '');
+}
+function getTaskArtifactTypes(project, taskId) {
+    return project.artifacts
+        .filter((row) => String(row.task_id) === String(taskId))
+        .map((row) => String(row.type || '').trim())
+        .filter(Boolean);
+}
+const DEFAULT_DATA_DIR = path.join(os.homedir(), '.q-ai-note', 'data');
+const FILE_NAME = 'aser-runtime-projects.json';
+const DEFAULT_PROTOCOL_PRESET_ID = 'engineering_protocol_v1';
+function getBuiltInProtocolFallback() {
+    return {
+        id: DEFAULT_PROTOCOL_PRESET_ID,
+        version: 1,
+        roles: [
+            { role_id: 'product_manager', intents: ['create_requirement', 'escalate_issue'] },
+            { role_id: 'architect', intents: ['design_system', 'clarify_design'] },
+            { role_id: 'developer', intents: ['implement_feature', 'report_issue', 'clarify_design'] },
+            { role_id: 'reviewer', intents: ['review_code', 'escalate_issue'] },
+        ],
+        intents: [
+            'create_requirement',
+            'design_system',
+            'implement_feature',
+            'review_code',
+            'clarify_design',
+            'report_issue',
+            'escalate_issue',
+        ],
+        intent_rules: [
+            { intent: 'design_system', requires: ['create_requirement'] },
+            { intent: 'implement_feature', requires: ['design_system'] },
+            { intent: 'review_code', requires: ['implement_feature'] },
+            { intent: 'escalate_issue', requires: ['report_issue'] },
+        ],
+        evaluation_templates: [
+            {
+                intent: 'implement_feature',
+                acceptance_criteria: ['code implemented', 'tests pass', 'design consistent'],
+                review_required: true,
+            },
+            {
+                intent: 'design_system',
+                acceptance_criteria: ['design doc available', 'dependencies validated'],
+                review_required: true,
+            },
+            {
+                intent: 'create_requirement',
+                acceptance_criteria: ['requirement complete', 'scope clear'],
+                review_required: false,
+            },
+            {
+                intent: 'review_code',
+                acceptance_criteria: ['review completed'],
+                review_required: false,
+            },
+            {
+                intent: 'clarify_design',
+                acceptance_criteria: ['clarification documented'],
+                review_required: false,
+            },
+            {
+                intent: 'report_issue',
+                acceptance_criteria: ['issue recorded'],
+                review_required: false,
+            },
+            {
+                intent: 'escalate_issue',
+                acceptance_criteria: ['escalation acknowledged', 'owner assigned'],
+                review_required: true,
+            },
+        ],
+        quality_gates: [
+            {
+                gate_id: 'G1',
+                stage: 'create_requirement',
+                required_evidence: ['requirement_doc'],
+                pass_when: 'requirement_is_complete',
+            },
+            {
+                gate_id: 'G2',
+                stage: 'design_system',
+                required_evidence: ['design_doc'],
+                pass_when: 'design_review_passed',
+            },
+            {
+                gate_id: 'G3',
+                stage: 'implement_feature',
+                required_evidence: ['pr', 'test_report'],
+                pass_when: 'implementation_tests_passed',
+            },
+            {
+                gate_id: 'G4',
+                stage: 'review_code',
+                required_evidence: ['review_record'],
+                pass_when: 'review_accepted',
+            },
+            {
+                gate_id: 'G5',
+                stage: 'escalate_issue',
+                required_evidence: ['risk_summary'],
+                pass_when: 'escalation_acknowledged',
+            },
+        ],
+        loop_actions: [
+            {
+                id: 'L1',
+                taxonomy: 'clarify_design',
+                trigger_event_types: ['message_posted'],
+                required_links: ['parent'],
+                closure_evidence: ['clarification_note'],
+            },
+            {
+                id: 'L2',
+                taxonomy: 'report_issue',
+                trigger_event_types: ['issue_reported', 'task_blocked'],
+                required_links: ['parent'],
+                closure_evidence: ['issue_record'],
+            },
+            {
+                id: 'L3',
+                taxonomy: 'escalate_issue',
+                trigger_event_types: ['escalation_requested'],
+                required_links: ['parent', 'related'],
+                closure_evidence: ['risk_summary'],
+            },
+        ],
+    };
+}
+function cloneProtocol(protocol) {
+    return {
+        id: protocol.id,
+        version: protocol.version,
+        roles: protocol.roles.map((row) => ({ role_id: row.role_id, intents: [...row.intents] })),
+        intents: [...protocol.intents],
+        intent_rules: protocol.intent_rules.map((row) => ({ intent: row.intent, requires: [...row.requires] })),
+        evaluation_templates: protocol.evaluation_templates.map((row) => ({
+            intent: row.intent,
+            acceptance_criteria: [...row.acceptance_criteria],
+            review_required: row.review_required,
+        })),
+        quality_gates: Array.isArray(protocol.quality_gates)
+            ? protocol.quality_gates.map((row) => ({
+                gate_id: String(row.gate_id || ''),
+                stage: String(row.stage || ''),
+                required_evidence: Array.isArray(row.required_evidence)
+                    ? row.required_evidence.map((value) => String(value || ''))
+                    : [],
+                pass_when: String(row.pass_when || ''),
+            }))
+            : [],
+        loop_actions: Array.isArray(protocol.loop_actions)
+            ? protocol.loop_actions.map((row) => ({
+                id: String(row.id || ''),
+                taxonomy: String(row.taxonomy || ''),
+                trigger_event_types: Array.isArray(row.trigger_event_types)
+                    ? row.trigger_event_types.map((value) => String(value || ''))
+                    : [],
+                required_links: Array.isArray(row.required_links)
+                    ? row.required_links.map((value) => String(value || ''))
+                    : [],
+                closure_evidence: Array.isArray(row.closure_evidence)
+                    ? row.closure_evidence.map((value) => String(value || ''))
+                    : [],
+            }))
+            : [],
+        updated_at: protocol.updated_at,
+    };
+}
+function resolveProtocolPresetPath(presetId) {
+    const fileName = `${presetId}.json`;
+    const currentFileDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(currentFileDir, 'presets', fileName),
+        path.resolve(process.cwd(), 'src', 'server', 'presets', fileName),
+        path.resolve(process.cwd(), 'dist', 'server', 'presets', fileName),
+    ];
+    const matched = candidates.find((candidate) => fs.existsSync(candidate));
+    return matched || null;
+}
+function readProtocolPresetOrFallback(presetId) {
+    const fallback = getBuiltInProtocolFallback();
+    const presetPath = resolveProtocolPresetPath(presetId);
+    if (!presetPath) {
+        return {
+            ...fallback,
+            updated_at: nowIso(),
+        };
+    }
+    try {
+        const text = fs.readFileSync(presetPath, 'utf-8');
+        const parsed = JSON.parse(text);
+        return {
+            id: String(parsed.id || fallback.id),
+            version: Number.isFinite(Number(parsed.version)) ? Number(parsed.version) : fallback.version,
+            roles: Array.isArray(parsed.roles) ? parsed.roles.map((row) => ({
+                role_id: row.role_id,
+                intents: Array.isArray(row.intents) ? row.intents.map((value) => String(value || '')) : [],
+            })) : fallback.roles,
+            intents: Array.isArray(parsed.intents) ? parsed.intents.map((value) => String(value || '')) : fallback.intents,
+            intent_rules: Array.isArray(parsed.intent_rules) ? parsed.intent_rules.map((row) => ({
+                intent: String(row.intent || ''),
+                requires: Array.isArray(row.requires) ? row.requires.map((value) => String(value || '')) : [],
+            })) : fallback.intent_rules,
+            evaluation_templates: Array.isArray(parsed.evaluation_templates) ? parsed.evaluation_templates.map((row) => ({
+                intent: String(row.intent || ''),
+                acceptance_criteria: Array.isArray(row.acceptance_criteria)
+                    ? row.acceptance_criteria.map((value) => String(value || ''))
+                    : [],
+                review_required: Boolean(row.review_required),
+            })) : fallback.evaluation_templates,
+            quality_gates: Array.isArray(parsed.quality_gates) ? parsed.quality_gates.map((row) => ({
+                gate_id: String(row.gate_id || ''),
+                stage: String(row.stage || ''),
+                required_evidence: Array.isArray(row.required_evidence)
+                    ? row.required_evidence.map((value) => String(value || ''))
+                    : [],
+                pass_when: String(row.pass_when || ''),
+            })) : fallback.quality_gates,
+            loop_actions: Array.isArray(parsed.loop_actions) ? parsed.loop_actions.map((row) => ({
+                id: String(row.id || ''),
+                taxonomy: String(row.taxonomy || ''),
+                trigger_event_types: Array.isArray(row.trigger_event_types)
+                    ? row.trigger_event_types.map((value) => String(value || ''))
+                    : [],
+                required_links: Array.isArray(row.required_links)
+                    ? row.required_links.map((value) => String(value || ''))
+                    : [],
+                closure_evidence: Array.isArray(row.closure_evidence)
+                    ? row.closure_evidence.map((value) => String(value || ''))
+                    : [],
+            })) : fallback.loop_actions,
+            updated_at: nowIso(),
+        };
+    }
+    catch {
+        return {
+            ...fallback,
+            updated_at: nowIso(),
+        };
+    }
+}
+const DEFAULT_PROTOCOL_TEMPLATE = readProtocolPresetOrFallback(DEFAULT_PROTOCOL_PRESET_ID);
+const DEFAULT_INTENTS = [...DEFAULT_PROTOCOL_TEMPLATE.intents];
+export function getDefaultProtocolPresetId() {
+    return DEFAULT_PROTOCOL_PRESET_ID;
+}
+export function getDefaultProtocolPreset() {
+    return cloneProtocol(DEFAULT_PROTOCOL_TEMPLATE);
+}
+export function getDefaultIntentTaxonomy() {
+    return [...DEFAULT_INTENTS];
+}
+function buildDefaultProtocol() {
+    const base = cloneProtocol(DEFAULT_PROTOCOL_TEMPLATE);
+    base.updated_at = nowIso();
+    return base;
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function stableStringify(input) {
+    const normalize = (value) => {
+        if (Array.isArray(value))
+            return value.map((item) => normalize(item));
+        if (value && typeof value === 'object') {
+            const obj = value;
+            return Object.keys(obj)
+                .sort()
+                .reduce((acc, key) => {
+                acc[key] = normalize(obj[key]);
+                return acc;
+            }, {});
+        }
+        return value;
+    };
+    return JSON.stringify(normalize(input), null, 2);
+}
+function ensureDir(dir) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+}
+function getDataDir() {
+    const fromEnv = process.env.Q_AI_NOTE_DATA_DIR || process.env.PERSONAL_AI_NOTEBOOK_DATA_DIR;
+    if (fromEnv && fromEnv.trim())
+        return path.resolve(fromEnv);
+    return DEFAULT_DATA_DIR;
+}
+function readData(filePath) {
+    if (!fs.existsSync(filePath))
+        return { projects: [] };
+    try {
+        const text = fs.readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(text);
+        if (!parsed || !Array.isArray(parsed.projects))
+            return { projects: [] };
+        return parsed;
+    }
+    catch {
+        return { projects: [] };
+    }
+}
+function writeData(filePath, data) {
+    const tmpFile = `${filePath}.tmp`;
+    fs.writeFileSync(tmpFile, stableStringify(data), 'utf-8');
+    fs.renameSync(tmpFile, filePath);
+}
+function normalizeTask(task) {
+    return {
+        ...task,
+        related: Array.isArray(task.related) ? task.related.map((value) => String(value || '')) : [],
+        artifacts: Array.isArray(task.artifacts) ? task.artifacts.map((value) => String(value || '')) : [],
+    };
+}
+function normalizeProject(project) {
+    const protocol = project.protocol && typeof project.protocol === 'object'
+        ? project.protocol
+        : buildDefaultProtocol();
+    return {
+        ...project,
+        events: Array.isArray(project.events) ? project.events : [],
+        intents: Array.isArray(project.intents) ? project.intents : [],
+        tasks: Array.isArray(project.tasks) ? project.tasks.map(normalizeTask) : [],
+        artifacts: Array.isArray(project.artifacts) ? project.artifacts : [],
+        evaluations: Array.isArray(project.evaluations) ? project.evaluations : [],
+        protocol: {
+            id: String(protocol.id || 'engineering_protocol_v1'),
+            version: Number.isFinite(Number(protocol.version)) ? Number(protocol.version) : 1,
+            roles: Array.isArray(protocol.roles) ? protocol.roles.map((row) => ({
+                role_id: row.role_id,
+                intents: Array.isArray(row.intents) ? row.intents.map((value) => String(value || '')) : [],
+            })) : buildDefaultProtocol().roles,
+            intents: Array.isArray(protocol.intents) ? protocol.intents.map((value) => String(value || '')) : [...DEFAULT_INTENTS],
+            intent_rules: Array.isArray(protocol.intent_rules) ? protocol.intent_rules.map((row) => ({
+                intent: String(row.intent || ''),
+                requires: Array.isArray(row.requires) ? row.requires.map((value) => String(value || '')) : [],
+            })) : buildDefaultProtocol().intent_rules,
+            evaluation_templates: Array.isArray(protocol.evaluation_templates) ? protocol.evaluation_templates.map((row) => ({
+                intent: String(row.intent || ''),
+                acceptance_criteria: Array.isArray(row.acceptance_criteria) ? row.acceptance_criteria.map((value) => String(value || '')) : [],
+                review_required: Boolean(row.review_required),
+            })) : buildDefaultProtocol().evaluation_templates,
+            quality_gates: Array.isArray(protocol.quality_gates) ? protocol.quality_gates.map((row) => ({
+                gate_id: String(row.gate_id || ''),
+                stage: String(row.stage || ''),
+                required_evidence: Array.isArray(row.required_evidence) ? row.required_evidence.map((value) => String(value || '')) : [],
+                pass_when: String(row.pass_when || ''),
+            })) : buildDefaultProtocol().quality_gates || [],
+            loop_actions: Array.isArray(protocol.loop_actions) ? protocol.loop_actions.map((row) => ({
+                id: String(row.id || ''),
+                taxonomy: String(row.taxonomy || ''),
+                trigger_event_types: Array.isArray(row.trigger_event_types) ? row.trigger_event_types.map((value) => String(value || '')) : [],
+                required_links: Array.isArray(row.required_links) ? row.required_links.map((value) => String(value || '')) : [],
+                closure_evidence: Array.isArray(row.closure_evidence) ? row.closure_evidence.map((value) => String(value || '')) : [],
+            })) : buildDefaultProtocol().loop_actions || [],
+            updated_at: String(protocol.updated_at || nowIso()),
+        },
+    };
+}
+function inferActorRole(actorRole, actor) {
+    const role = String(actorRole || '').trim();
+    if (role === 'product_manager' || role === 'architect' || role === 'developer' || role === 'reviewer') {
+        return role;
+    }
+    const actorText = String(actor || '').toLowerCase();
+    if (actorText.includes('review'))
+        return 'reviewer';
+    if (actorText.includes('arch'))
+        return 'architect';
+    if (actorText.includes('pm') || actorText.includes('product'))
+        return 'product_manager';
+    return 'developer';
+}
+function detectIntentFromEvent(input) {
+    const payloadIntent = String(input.payload?.intent_taxonomy || '').trim();
+    if (payloadIntent)
+        return payloadIntent;
+    const eventType = String(input.event_type || '').trim();
+    if (eventType === 'message_posted')
+        return 'clarify_design';
+    if (eventType === 'requirement_defined')
+        return 'create_requirement';
+    if (eventType === 'design_defined')
+        return 'design_system';
+    if (eventType === 'implementation_reported')
+        return 'implement_feature';
+    if (eventType === 'review_requested')
+        return 'review_code';
+    if (eventType === 'issue_reported' || eventType === 'task_blocked')
+        return 'report_issue';
+    if (eventType === 'escalation_requested')
+        return 'escalate_issue';
+    return null;
+}
+export class AserRuntimeStore {
+    loaded = false;
+    filePath = '';
+    data = { projects: [] };
+    dataDirOverride;
+    constructor(dataDirOverride) {
+        this.dataDirOverride = dataDirOverride && dataDirOverride.trim()
+            ? path.resolve(dataDirOverride)
+            : undefined;
+    }
+    ensureLoaded() {
+        if (this.loaded)
+            return;
+        const dataDir = this.dataDirOverride || getDataDir();
+        ensureDir(dataDir);
+        this.filePath = path.join(dataDir, FILE_NAME);
+        this.data = readData(this.filePath);
+        this.data.projects = this.data.projects.map(normalizeProject);
+        this.loaded = true;
+    }
+    persist() {
+        this.data.projects = this.data.projects
+            .map(normalizeProject)
+            .sort((a, b) => String(a.created_at || '').localeCompare(String(b.created_at || '')));
+        writeData(this.filePath, this.data);
+    }
+    listProjects() {
+        this.ensureLoaded();
+        return this.data.projects.map((project) => normalizeProject(project));
+    }
+    getProject(projectId) {
+        this.ensureLoaded();
+        const row = this.data.projects.find((project) => String(project.id) === String(projectId));
+        return row ? normalizeProject(row) : null;
+    }
+    createProject(name, description = '') {
+        this.ensureLoaded();
+        const timestamp = nowIso();
+        const project = {
+            id: uuidv4(),
+            name: String(name || '').trim(),
+            description: String(description || ''),
+            created_at: timestamp,
+            updated_at: timestamp,
+            events: [],
+            intents: [],
+            tasks: [],
+            artifacts: [],
+            evaluations: [],
+            protocol: buildDefaultProtocol(),
+        };
+        this.data.projects.push(project);
+        this.persist();
+        return normalizeProject(project);
+    }
+    deleteProject(projectId) {
+        this.ensureLoaded();
+        const before = this.data.projects.length;
+        this.data.projects = this.data.projects.filter((project) => String(project.id) !== String(projectId));
+        if (this.data.projects.length === before)
+            return false;
+        this.persist();
+        return true;
+    }
+    getProtocol(projectId) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        return normalizeProject(project).protocol;
+    }
+    updateProtocol(projectId, protocol) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        const current = normalizeProject(project).protocol;
+        const next = {
+            ...current,
+            id: String(protocol.id || current.id || 'engineering_protocol_v1'),
+            version: Number.isFinite(Number(protocol.version)) ? Number(protocol.version) : current.version + 1,
+            roles: Array.isArray(protocol.roles) ? protocol.roles.map((row) => ({
+                role_id: row.role_id,
+                intents: Array.isArray(row.intents) ? row.intents.map((value) => String(value || '')) : [],
+            })) : current.roles,
+            intents: Array.isArray(protocol.intents) ? protocol.intents.map((value) => String(value || '')) : current.intents,
+            intent_rules: Array.isArray(protocol.intent_rules) ? protocol.intent_rules.map((row) => ({
+                intent: String(row.intent || ''),
+                requires: Array.isArray(row.requires) ? row.requires.map((value) => String(value || '')) : [],
+            })) : current.intent_rules,
+            evaluation_templates: Array.isArray(protocol.evaluation_templates) ? protocol.evaluation_templates.map((row) => ({
+                intent: String(row.intent || ''),
+                acceptance_criteria: Array.isArray(row.acceptance_criteria) ? row.acceptance_criteria.map((value) => String(value || '')) : [],
+                review_required: Boolean(row.review_required),
+            })) : current.evaluation_templates,
+            quality_gates: Array.isArray(protocol.quality_gates) ? protocol.quality_gates.map((row) => ({
+                gate_id: String(row.gate_id || ''),
+                stage: String(row.stage || ''),
+                required_evidence: Array.isArray(row.required_evidence) ? row.required_evidence.map((value) => String(value || '')) : [],
+                pass_when: String(row.pass_when || ''),
+            })) : (current.quality_gates || []),
+            loop_actions: Array.isArray(protocol.loop_actions) ? protocol.loop_actions.map((row) => ({
+                id: String(row.id || ''),
+                taxonomy: String(row.taxonomy || ''),
+                trigger_event_types: Array.isArray(row.trigger_event_types) ? row.trigger_event_types.map((value) => String(value || '')) : [],
+                required_links: Array.isArray(row.required_links) ? row.required_links.map((value) => String(value || '')) : [],
+                closure_evidence: Array.isArray(row.closure_evidence) ? row.closure_evidence.map((value) => String(value || '')) : [],
+            })) : (current.loop_actions || []),
+            updated_at: nowIso(),
+        };
+        project.protocol = next;
+        project.updated_at = next.updated_at;
+        this.persist();
+        return next;
+    }
+    appendEvent(projectId, input) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        const event = {
+            id: uuidv4(),
+            actor: String(input.actor || '').trim(),
+            actor_kind: input.actor_kind,
+            timestamp: nowIso(),
+            type: String(input.type || '').trim(),
+            payload: input.payload && typeof input.payload === 'object' ? input.payload : {},
+        };
+        project.events.push(event);
+        project.updated_at = nowIso();
+        this.persist();
+        return event;
+    }
+    submitEvent(projectId, input) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        const normalizedProject = normalizeProject(project);
+        project.protocol = normalizedProject.protocol;
+        const event = this.appendEvent(projectId, input);
+        if (!event)
+            return null;
+        const violations = [];
+        const detectedIntent = detectIntentFromEvent({
+            event_type: input.type,
+            payload: input.payload,
+        });
+        if (!detectedIntent) {
+            return { event, intent: null, task: null, violations };
+        }
+        if (!project.protocol.intents.includes(detectedIntent)) {
+            violations.push(`intent_not_in_protocol:${detectedIntent}`);
+            return { event, intent: null, task: null, violations };
+        }
+        const role = inferActorRole(input.actor_role, input.actor);
+        const roleDef = project.protocol.roles.find((row) => row.role_id === role);
+        if (!roleDef || !roleDef.intents.includes(detectedIntent)) {
+            violations.push(`role_intent_forbidden:${role}:${detectedIntent}`);
+            return { event, intent: null, task: null, violations };
+        }
+        const rule = project.protocol.intent_rules.find((row) => row.intent === detectedIntent);
+        if (rule && rule.requires.length) {
+            const fulfilled = rule.requires.every((requiredIntent) => {
+                return project.tasks.some((task) => String(task.intent_id || '').includes(requiredIntent)
+                    || (task.status === 'accepted' && project.intents.some((intent) => intent.id === task.intent_id && intent.taxonomy === requiredIntent)));
+            });
+            if (!fulfilled) {
+                violations.push(`intent_dependency_not_met:${detectedIntent}`);
+                return { event, intent: null, task: null, violations };
+            }
+        }
+        const intent = this.createIntent(projectId, {
+            taxonomy: detectedIntent,
+            title: String(input.payload?.intent_title || `${detectedIntent} from ${input.type}`),
+            source_event_id: event.id,
+        });
+        if (!intent)
+            return { event, intent: null, task: null, violations };
+        const evalTemplate = project.protocol.evaluation_templates.find((row) => row.intent === detectedIntent);
+        const task = this.createTask(projectId, {
+            intent_id: intent.id,
+            title: String(input.payload?.task_title || intent.title || detectedIntent),
+            owner_role: role,
+            preferred_agent: String(input.payload?.preferred_agent || ''),
+            parent: input.payload?.parent ? String(input.payload.parent) : null,
+            related: Array.isArray(input.payload?.related)
+                ? input.payload.related.map((value) => String(value || '')).filter((value) => Boolean(value))
+                : [],
+            acceptance_criteria: evalTemplate?.acceptance_criteria?.join('; ') || String(input.payload?.acceptance_criteria || ''),
+            evaluation_policy: evalTemplate
+                ? JSON.stringify({ review_required: Boolean(evalTemplate.review_required) })
+                : String(input.payload?.evaluation_policy || ''),
+        });
+        return { event, intent, task, violations };
+    }
+    createIntent(projectId, input) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        const intent = {
+            id: uuidv4(),
+            taxonomy: String(input.taxonomy || '').trim(),
+            title: String(input.title || '').trim(),
+            source_event_id: input.source_event_id ? String(input.source_event_id) : null,
+            created_at: nowIso(),
+        };
+        project.intents.push(intent);
+        project.updated_at = nowIso();
+        this.persist();
+        return intent;
+    }
+    createTask(projectId, input) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        const timestamp = nowIso();
+        const task = {
+            id: uuidv4(),
+            intent_id: String(input.intent_id || '').trim(),
+            title: String(input.title || '').trim(),
+            status: 'created',
+            owner_role: String(input.owner_role || '').trim(),
+            preferred_agent: String(input.preferred_agent || '').trim(),
+            parent: input.parent ? String(input.parent) : null,
+            related: Array.isArray(input.related) ? input.related.map((value) => String(value || '')) : [],
+            acceptance_criteria: String(input.acceptance_criteria || ''),
+            evaluation_policy: String(input.evaluation_policy || ''),
+            artifacts: [],
+            created_at: timestamp,
+            updated_at: timestamp,
+        };
+        project.tasks.push(task);
+        project.updated_at = nowIso();
+        this.persist();
+        return task;
+    }
+    pullTask(projectId, role) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        const nextTask = [...project.tasks]
+            .filter((task) => task.owner_role === role && (task.status === 'created' || task.status === 'ready'))
+            .sort((a, b) => String(a.created_at || '').localeCompare(String(b.created_at || '')))[0];
+        if (!nextTask)
+            return null;
+        nextTask.status = 'in_progress';
+        nextTask.updated_at = nowIso();
+        project.updated_at = nextTask.updated_at;
+        this.persist();
+        const intent = project.intents.find((row) => row.id === nextTask.intent_id) || null;
+        const relatedEvents = project.events
+            .filter((row) => row.id === intent?.source_event_id)
+            .slice(0, 20);
+        const artifacts = project.artifacts.filter((row) => row.task_id === nextTask.id);
+        return {
+            task: normalizeTask(nextTask),
+            context: {
+                project_id: projectId,
+                intent,
+                related_events: relatedEvents,
+                artifacts,
+            },
+        };
+    }
+    submitTaskResult(projectId, taskId, input) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        const task = project.tasks.find((row) => row.id === taskId);
+        if (!task)
+            return null;
+        if (Array.isArray(input.artifacts)) {
+            input.artifacts.forEach((artifact) => {
+                if (!artifact || !artifact.type || !artifact.uri)
+                    return;
+                this.addArtifact(projectId, taskId, artifact);
+            });
+        }
+        if (input.mark_blocked) {
+            task.status = 'blocked';
+        }
+        else {
+            const evalPolicy = String(task.evaluation_policy || '');
+            const reviewRequired = evalPolicy.includes('review_required') && evalPolicy.includes('true');
+            task.status = reviewRequired ? 'evaluating' : 'completed';
+        }
+        task.updated_at = nowIso();
+        project.updated_at = task.updated_at;
+        this.appendEvent(projectId, {
+            actor: input.actor || input.role || 'worker',
+            actor_kind: 'agent',
+            type: input.mark_blocked ? 'task_blocked' : 'task_completed',
+            payload: {
+                task_id: taskId,
+                blocked_reason: input.blocked_reason || '',
+            },
+        });
+        this.persist();
+        return normalizeTask(task);
+    }
+    updateTaskStatus(projectId, taskId, status) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        const task = project.tasks.find((row) => row.id === taskId);
+        if (!task)
+            return null;
+        task.status = status;
+        task.updated_at = nowIso();
+        project.updated_at = task.updated_at;
+        this.persist();
+        return normalizeTask(task);
+    }
+    addArtifact(projectId, taskId, input) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        const task = project.tasks.find((row) => row.id === taskId);
+        if (!task)
+            return null;
+        const artifact = {
+            id: uuidv4(),
+            task_id: taskId,
+            type: String(input.type || '').trim(),
+            uri: String(input.uri || '').trim(),
+            summary: String(input.summary || ''),
+            created_at: nowIso(),
+        };
+        project.artifacts.push(artifact);
+        task.artifacts.push(artifact.id);
+        task.updated_at = nowIso();
+        project.updated_at = task.updated_at;
+        this.persist();
+        return artifact;
+    }
+    addEvaluation(projectId, taskId, input) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        const task = project.tasks.find((row) => row.id === taskId);
+        if (!task)
+            return null;
+        let finalDecision = input.decision;
+        const taskTaxonomy = findIntentTaxonomy(project, task);
+        const gate = (project.protocol.quality_gates || []).find((row) => String(row.stage || '') === taskTaxonomy);
+        const expectedEvidence = Array.isArray(gate?.required_evidence)
+            ? gate.required_evidence.map((row) => String(row || '').trim()).filter(Boolean)
+            : [];
+        const providedEvidence = getTaskArtifactTypes(project, task.id);
+        const missingEvidence = expectedEvidence.filter((type) => !providedEvidence.includes(type));
+        let mergedComments = String(input.comments || '');
+        if (input.decision === 'accept' && missingEvidence.length > 0) {
+            finalDecision = 'revise';
+            const gateId = String(gate?.gate_id || 'gate');
+            const detail = `gate_blocked:${gateId}:missing_evidence:${missingEvidence.join(',')}`;
+            mergedComments = mergedComments ? `${mergedComments} | ${detail}` : detail;
+            this.appendEvent(projectId, {
+                actor: String(input.evaluator || 'reviewer'),
+                actor_kind: 'human',
+                type: 'quality_gate_blocked',
+                payload: {
+                    task_id: task.id,
+                    gate_id: gateId,
+                    expected_evidence: expectedEvidence,
+                    provided_evidence: providedEvidence,
+                    missing_evidence: missingEvidence,
+                },
+            });
+        }
+        const evaluation = {
+            id: uuidv4(),
+            task_id: taskId,
+            evaluator: String(input.evaluator || '').trim(),
+            decision: finalDecision,
+            score: Number.isFinite(Number(input.score)) ? Number(input.score) : 0,
+            comments: mergedComments,
+            created_at: nowIso(),
+        };
+        project.evaluations.push(evaluation);
+        task.status = finalDecision === 'accept'
+            ? 'accepted'
+            : finalDecision === 'revise'
+                ? 'failed'
+                : 'failed';
+        task.updated_at = nowIso();
+        project.updated_at = task.updated_at;
+        this.persist();
+        return evaluation;
+    }
+    getProjectState(projectId) {
+        this.ensureLoaded();
+        const project = this.data.projects.find((row) => row.id === projectId);
+        if (!project)
+            return null;
+        const total = project.tasks.length;
+        const accepted = project.tasks.filter((task) => task.status === 'accepted').length;
+        const blocked = project.tasks.filter((task) => task.status === 'blocked').length;
+        const reviewPending = project.tasks.filter((task) => task.status === 'evaluating').length;
+        const failed = project.tasks.filter((task) => task.status === 'failed').length;
+        const gateBlockedEvents = project.events.filter((event) => String(event.type || '') === 'quality_gate_blocked').length;
+        const latestEvent = [...project.events]
+            .sort((a, b) => String(b.timestamp || '').localeCompare(String(a.timestamp || '')))[0];
+        return {
+            feature_completion: total <= 0 ? 0 : Number(((accepted / total) * 100).toFixed(2)),
+            accepted_tasks: accepted,
+            total_tasks: total,
+            blocked_tasks: blocked,
+            review_pending_tasks: reviewPending,
+            failed_tasks: failed,
+            quality_gate_blocked_events: gateBlockedEvents,
+            last_event_at: latestEvent?.timestamp || null,
+        };
+    }
+}
+export const aserRuntimeStore = new AserRuntimeStore();
+//# sourceMappingURL=aserRuntimeStore.js.map