ai-growth 1.1.0

package/dist/core/actions.js

@@ -0,0 +1,264 @@
+import { writeAudit } from './context.js';
+import { newId, ts } from '../shared/util.js';
+import { assertActionTransition, isTerminalActionStatus } from './stateMachine.js';
+import { DomainError, ErrorCodes } from '../shared/result.js';
+import { todayIn, resolveTimezone, getProfile } from './profile.js';
+import { localDateKey } from '../shared/time.js';
+import { cancelRemindersByAction } from '../reminder/service.js';
+function rowToAction(r) {
+    return {
+        id: r.id, kind: r.kind, domain: r.domain, title: r.title,
+        description: r.description ?? undefined, whyToday: r.why_today ?? undefined,
+        estimatedMinutes: r.estimated_minutes ?? undefined,
+        completionCriteria: r.completion_criteria ?? undefined,
+        evidenceRequirements: r.evidence_requirements ?? undefined,
+        verificationStrategy: r.verification_strategy ?? undefined, basis: r.basis ?? undefined,
+        basisGoalId: r.basis_goal_id ?? undefined, basisDirectionId: r.basis_direction_id ?? undefined,
+        basisStageId: r.basis_stage_id ?? undefined, planId: r.plan_id ?? undefined,
+        dateKey: r.date_key, status: r.status,
+        skippedReason: r.skipped_reason ?? undefined, completedAt: r.completed_at ?? undefined,
+        createdAt: r.created_at, updatedAt: r.updated_at,
+    };
+}
+// ---------- daily plans ----------
+export function getDailyPlan(ctx, dateKey) {
+    const row = ctx.db
+        .prepare('SELECT * FROM daily_plans WHERE date_key=?')
+        .get(dateKey);
+    if (!row)
+        return null;
+    return {
+        id: row.id, dateKey: row.date_key, rationale: row.rationale ?? undefined,
+        status: row.status, createdAt: row.created_at, confirmedAt: row.confirmed_at ?? undefined,
+    };
+}
+export function getTodayPlan(ctx) {
+    const today = todayIn(ctx);
+    const plan = getDailyPlan(ctx, today);
+    return { plan, actions: plan ? listActionsForDate(ctx, today) : [] };
+}
+/**
+ * 创建今日计划（Core 保证结构性约束，V1.1 §23）：
+ * - 必须先完成 Onboarding（核心原则 2：不允许直接生成任务）
+ * - 有未处理的 Pending Replan 时不得创建新 Main Quest（先解决 Replan）
+ * - Main Quest <= 1，Daily 0~2
+ * - Main 必须有完成标准、预计耗时、whyToday
+ * - 同一天已存在计划时返回错误（改用 confirm/update）
+ */
+export function createTodayPlan(ctx, input) {
+    // 结构性强制核心原则 2：首次使用必须先完成访谈，Agent 无法用"忘记"绕过
+    const profile = getProfile(ctx);
+    if (!profile || profile.onboardingStatus !== 'COMPLETED') {
+        throw new DomainError(ErrorCodes.ONBOARDING_REQUIRED, 'Onboarding must be COMPLETED before daily planning. Interview the user first, then call plan_today.');
+    }
+    const today = todayIn(ctx);
+    if (getDailyPlan(ctx, today)) {
+        throw new DomainError(ErrorCodes.ALREADY_EXISTS, `Plan for ${today} already exists`);
+    }
+    // 结构性强制：有 Pending Replan 时先解决它再开新主线，避免旧主线被静默丢弃
+    if (input.mainQuest) {
+        const pending = ctx.db
+            .prepare(`SELECT COUNT(*) AS n FROM actions WHERE status='PENDING_REPLAN' AND deleted_at IS NULL`)
+            .get();
+        if (pending.n > 0) {
+            throw new DomainError(ErrorCodes.REPLAN_REQUIRED, 'A previous Main Quest is pending replan. Resolve it with replan() before creating a new Main Quest.');
+        }
+    }
+    const dailies = input.dailyActions ?? [];
+    if (dailies.length > 2)
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Daily Actions must be 0~2 by default (V1.1 §23.1)');
+    const main = input.mainQuest;
+    if (main) {
+        if (!main.completionCriteria?.trim())
+            throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Main Quest requires completion criteria');
+        if (!main.estimatedMinutes)
+            throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Main Quest requires estimated time');
+        if (!main.whyToday?.trim())
+            throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Main Quest requires whyToday');
+    }
+    const planId = newId();
+    const now = ts();
+    const tx = ctx.db.transaction(() => {
+        ctx.db
+            .prepare('INSERT INTO daily_plans (id, date_key, rationale, status, created_at) VALUES (?,?,?,?,?)')
+            .run(planId, today, input.rationale ?? null, 'DRAFT', now);
+        if (main)
+            insertAction(ctx, { ...main, kind: 'MAIN_QUEST', planId, dateKey: today });
+        for (const d of dailies)
+            insertAction(ctx, { ...d, kind: 'DAILY', planId, dateKey: today });
+    });
+    tx();
+    writeAudit(ctx, {
+        entityType: 'daily_plan', entityId: planId,
+        after: { date: today, mainQuest: !!main, dailyCount: dailies.length },
+        reason: 'create today plan',
+    });
+    const plan = getDailyPlan(ctx, today);
+    return { plan, actions: listActionsForDate(ctx, today) };
+}
+/**
+ * 确认当日计划。确认后该计划下的 DRAFT action 进入 PLANNED 可执行态。
+ * 幂等：已确认的计划再次调用直接返回，不重复写审计。
+ */
+export function confirmTodayPlan(ctx, planId) {
+    let dateKey = todayIn(ctx);
+    if (planId) {
+        const target = ctx.db.prepare('SELECT date_key FROM daily_plans WHERE id=?').get(planId);
+        if (!target)
+            throw new DomainError(ErrorCodes.NOT_FOUND, `Plan not found: ${planId}`);
+        dateKey = target.date_key;
+    }
+    const plan = getDailyPlan(ctx, dateKey);
+    if (!plan)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `No plan for ${dateKey}`);
+    if (plan.status === 'CONFIRMED')
+        return plan;
+    ctx.db
+        .prepare('UPDATE daily_plans SET status=?, confirmed_at=? WHERE id=?')
+        .run('CONFIRMED', ts(), plan.id);
+    ctx.db
+        .prepare(`UPDATE actions SET status='PLANNED', updated_at=? WHERE plan_id=? AND status='DRAFT'`)
+        .run(ts(), plan.id);
+    const after = getDailyPlan(ctx, dateKey);
+    writeAudit(ctx, { entityType: 'daily_plan', entityId: plan.id, after, reason: 'user confirmed plan' });
+    return after;
+}
+function insertAction(ctx, input) {
+    const id = newId();
+    const now = ts();
+    ctx.db
+        .prepare(`INSERT INTO actions (id, kind, domain, title, description, why_today, estimated_minutes,
+       completion_criteria, evidence_requirements, verification_strategy, basis, basis_goal_id,
+       basis_direction_id, basis_stage_id, plan_id, date_key, status, created_at, updated_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
+        .run(id, input.kind, input.domain ?? 'OTHER', input.title, input.description ?? null, input.whyToday ?? null, input.estimatedMinutes ?? null, input.completionCriteria ?? null, input.evidenceRequirements ?? null, input.verificationStrategy ?? null, input.basis ?? null, input.basisGoalId ?? null, input.basisDirectionId ?? null, input.basisStageId ?? null, input.planId ?? null, input.dateKey, 'DRAFT', now, now);
+    return getAction(ctx, id);
+}
+/** Agent 自主创建执行层 action（V1.1 §17.2：当天执行层任务可自主创建） */
+export function createAction(ctx, input) {
+    const kind = input.kind ?? 'DAILY';
+    const dateKey = input.dateKey ?? todayIn(ctx);
+    const a = insertAction(ctx, { ...input, kind, dateKey });
+    // 创建即视为已规划（Agent 创建执行层任务无需用户逐条确认）
+    ctx.db.prepare(`UPDATE actions SET status='PLANNED', updated_at=? WHERE id=?`).run(ts(), a.id);
+    writeAudit(ctx, { entityType: 'action', entityId: a.id, after: getAction(ctx, a.id), reason: 'agent created action' });
+    return getAction(ctx, a.id);
+}
+export function getAction(ctx, id) {
+    const row = ctx.db.prepare('SELECT * FROM actions WHERE id=? AND deleted_at IS NULL').get(id);
+    return row ? rowToAction(row) : null;
+}
+export function listActionsForDate(ctx, dateKey) {
+    const rows = ctx.db
+        .prepare('SELECT * FROM actions WHERE date_key=? AND deleted_at IS NULL ORDER BY kind DESC, created_at')
+        .all(dateKey);
+    return rows.map(rowToAction);
+}
+export function listOpenActionsBefore(ctx, dateKey) {
+    const rows = ctx.db
+        .prepare(`SELECT * FROM actions WHERE date_key < ? AND deleted_at IS NULL
+       AND status IN ('DRAFT','PLANNED','IN_PROGRESS','DELAYED','PENDING_REPLAN')
+       ORDER BY date_key, created_at`)
+        .all(dateKey);
+    return rows.map(rowToAction);
+}
+function transitionAction(ctx, id, to, reason, extra = {}) {
+    const before = getAction(ctx, id);
+    if (!before)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Action not found: ${id}`);
+    // 用户对 DRAFT（尚未确认的当日计划）执行动作，本身就是对该计划的认可。
+    // 自动提升 DRAFT → PLANNED，避免用户点了「完成」却收到状态机报错
+    // （符合 §21「低风险任务允许一句话确认」与"不让用户管理系统"的定位）。
+    let from = before.status;
+    if (from === 'DRAFT' && to !== 'PLANNED' && to !== 'CANCELLED') {
+        ctx.db.prepare(`UPDATE actions SET status='PLANNED', updated_at=? WHERE id=?`).run(ts(), id);
+        from = 'PLANNED';
+    }
+    assertActionTransition(from, to, before.kind);
+    ctx.db
+        .prepare('UPDATE actions SET status=?, skipped_reason=?, completed_at=?, updated_at=? WHERE id=?')
+        .run(to, extra.skippedReason ?? before.skippedReason ?? null, to === 'COMPLETED' ? ts() : before.completedAt ?? null, ts(), id);
+    if (isTerminalActionStatus(to)) {
+        // Action 终态：取消未触发提醒（V1.1 §24 / Scenario I）
+        cancelRemindersByAction(ctx, id, `action ${to}`);
+    }
+    const after = getAction(ctx, id);
+    writeAudit(ctx, { entityType: 'action', entityId: id, before, after, reason });
+    return after;
+}
+export function startAction(ctx, id) {
+    return transitionAction(ctx, id, 'IN_PROGRESS', 'start action');
+}
+/** Agent 自主修改执行层任务（V1.1 §17.2）。修改顺带把 PENDING_REPLAN/DRAFT 拉回 PLANNED 由调用方决定 */
+export function updateAction(ctx, id, input, reason = 'agent update action') {
+    const before = getAction(ctx, id);
+    if (!before)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Action not found: ${id}`);
+    if (isTerminalActionStatus(before.status))
+        throw new DomainError(ErrorCodes.INVALID_STATE, `Cannot update terminal action (${before.status})`);
+    ctx.db
+        .prepare(`UPDATE actions SET title=?, description=?, why_today=?, estimated_minutes=?, completion_criteria=?,
+       evidence_requirements=?, verification_strategy=?, date_key=?, updated_at=? WHERE id=?`)
+        .run(input.title ?? before.title, input.description ?? before.description ?? null, input.whyToday ?? before.whyToday ?? null, input.estimatedMinutes ?? before.estimatedMinutes ?? null, input.completionCriteria ?? before.completionCriteria ?? null, input.evidenceRequirements ?? before.evidenceRequirements ?? null, input.verificationStrategy ?? before.verificationStrategy ?? null, input.dateKey ?? before.dateKey, ts(), id);
+    const after = getAction(ctx, id);
+    writeAudit(ctx, { entityType: 'action', entityId: id, before, after, reason });
+    return after;
+}
+/** 完成 action。delay/skip 必须带 reason；complete 后触发 GrowthEvent 由 evidence 服务负责 */
+export function completeAction(ctx, id) {
+    return transitionAction(ctx, id, 'COMPLETED', 'user completed action');
+}
+export function skipAction(ctx, id, reason) {
+    return transitionAction(ctx, id, 'SKIPPED', 'user skipped action', { skippedReason: reason });
+}
+export function delayAction(ctx, id, reason) {
+    const delayed = transitionAction(ctx, id, 'DELAYED', 'user delayed action');
+    if (!reason)
+        return delayed;
+    ctx.db.prepare('UPDATE actions SET skipped_reason=?, updated_at=? WHERE id=?').run(reason, ts(), id);
+    return getAction(ctx, id);
+}
+export function cancelAction(ctx, id, reason) {
+    return transitionAction(ctx, id, 'CANCELLED', reason);
+}
+/** Replan 内部使用：把 PENDING_REPLAN/DELAYED 的 Main Quest 拉回 PLANNED（可同时改日期） */
+export function rearmAction(ctx, id, newDateKey) {
+    if (newDateKey)
+        updateAction(ctx, id, { dateKey: newDateKey }, 'replan move date');
+    return transitionAction(ctx, id, 'PLANNED', 'replanned');
+}
+// rollover 专用（绕过一般转换约束由状态机保证）
+export function expireActionInternal(ctx, id) {
+    return transitionAction(ctx, id, 'EXPIRED', 'daily rollover: not completed by end of day');
+}
+export function markPendingReplanInternal(ctx, id) {
+    return transitionAction(ctx, id, 'PENDING_REPLAN', 'daily rollover: main quest not completed');
+}
+// ---------- task feedback（V1.1 §20）----------
+export function addTaskFeedback(ctx, actionId, reason, comment) {
+    const action = getAction(ctx, actionId);
+    if (!action)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Action not found: ${actionId}`);
+    const id = newId();
+    ctx.db
+        .prepare('INSERT INTO task_feedback (id, action_id, reason, comment, created_at) VALUES (?,?,?,?,?)')
+        .run(id, actionId, reason, comment ?? null, ts());
+    writeAudit(ctx, { entityType: 'task_feedback', entityId: id, after: { actionId, reason, comment }, reason: 'user feedback' });
+    return { id, actionId, reason, comment, createdAt: ts() };
+}
+export function listFeedbackForAction(ctx, actionId) {
+    const rows = ctx.db
+        .prepare('SELECT * FROM task_feedback WHERE action_id=? ORDER BY created_at DESC')
+        .all(actionId);
+    return rows.map((r) => ({ id: r.id, actionId: r.action_id, reason: r.reason, comment: r.comment ?? undefined, createdAt: r.created_at }));
+}
+/** 近 N 天反馈聚合（供 Planner 降低重复推荐概率） */
+export function recentFeedbackStats(ctx, days = 14) {
+    const since = localDateKey(new Date(Date.now() - days * 86400_000), resolveTimezone(ctx));
+    const rows = ctx.db
+        .prepare(`SELECT tf.reason AS reason, COUNT(*) AS count FROM task_feedback tf
+       JOIN actions a ON a.id = tf.action_id
+       WHERE a.date_key >= ? GROUP BY tf.reason ORDER BY count DESC`)
+        .all(since);
+    return rows.map((r) => ({ reason: r.reason, count: r.count }));
+}

package/dist/core/context.js

@@ -0,0 +1,7 @@
+import { newId, ts } from '../shared/util.js';
+export function writeAudit(ctx, entry) {
+    ctx.db
+        .prepare(`INSERT INTO audit_log (id, actor, entity_type, entity_id, before, after, reason, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(newId(), ctx.actor, entry.entityType, entry.entityId, entry.before === undefined ? null : JSON.stringify(entry.before), entry.after === undefined ? null : JSON.stringify(entry.after), entry.reason ?? null, ts());
+}

package/dist/core/directions.js

@@ -0,0 +1,26 @@
+import { newId, ts } from '../shared/util.js';
+import { DomainError, ErrorCodes } from '../shared/result.js';
+/** Daily Action 只能来自用户明确认可过的方向 / 意图 / 约束（核心原则 7）。 */
+export function listDirections(ctx, onlyConfirmed = true) {
+    const rows = onlyConfirmed
+        ? ctx.db.prepare('SELECT * FROM directions WHERE deleted_at IS NULL AND confirmed=1 ORDER BY created_at').all()
+        : ctx.db.prepare('SELECT * FROM directions WHERE deleted_at IS NULL ORDER BY created_at').all();
+    return rows;
+}
+export function addDirection(ctx, input) {
+    // 新增长期方向必须用户确认（V1.1 §17.4）；Agent 推断的只能作为 INFERRED 未确认
+    const id = newId();
+    const now = ts();
+    ctx.db
+        .prepare(`INSERT INTO directions (id, title, description, domain, origin, confirmed, created_at, updated_at)
+       VALUES (?,?,?,?,?,?,?,?)`)
+        .run(id, input.title, input.description ?? null, input.domain ?? 'OTHER', input.confirmed ? 'USER_CONFIRMED' : 'INFERRED', input.confirmed ? 1 : 0, now, now);
+    return ctx.db.prepare('SELECT * FROM directions WHERE id=?').get(id);
+}
+export function confirmDirection(ctx, id) {
+    const r = ctx.db.prepare('SELECT * FROM directions WHERE id=?').get(id);
+    if (!r)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Direction not found: ${id}`);
+    ctx.db.prepare('UPDATE directions SET confirmed=1, origin=?, updated_at=? WHERE id=?').run('USER_CONFIRMED', ts(), id);
+    return ctx.db.prepare('SELECT * FROM directions WHERE id=?').get(id);
+}

package/dist/core/evidence.js

@@ -0,0 +1,155 @@
+import { writeAudit } from './context.js';
+import { newId, ts, pj } from '../shared/util.js';
+import { DomainError, ErrorCodes } from '../shared/result.js';
+import { todayIn, resolveTimezone } from './profile.js';
+import { startOfDateKey } from '../shared/time.js';
+import { flagPassportDirty } from '../passport/state.js';
+function rowToEvidence(r) {
+    return {
+        id: r.id, actionId: r.action_id ?? undefined, type: r.type,
+        strength: r.strength, content: r.content,
+        metadata: pj(r.metadata, {}), createdAt: r.created_at,
+    };
+}
+/**
+ * 记录 Evidence。UNVERIFIED 证据不能用于自动宣布完成关键目标（调用方约束），
+ * 自动验证类（GIT/METRIC/QUIZ 结果）默认 AUTO_VERIFIED。
+ */
+export function addEvidence(ctx, input) {
+    if (!input.content?.trim())
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Evidence content is required');
+    const id = newId();
+    const strength = input.strength ??
+        (['GIT', 'METRIC', 'QUIZ', 'ARTIFACT'].includes(input.type) ? 'AUTO_VERIFIED' : 'USER_CONFIRMED');
+    ctx.db
+        .prepare(`INSERT INTO evidence (id, action_id, type, strength, content, metadata, created_at)
+       VALUES (?,?,?,?,?,?,?)`)
+        .run(id, input.actionId ?? null, input.type, strength, input.content.trim(), JSON.stringify(input.metadata ?? {}), ts());
+    const ev = ctx.db.prepare('SELECT * FROM evidence WHERE id=?').get(id);
+    flagPassportDirty(ctx, 'evidence added');
+    return rowToEvidence(ev);
+}
+export function listEvidence(ctx, filters = {}) {
+    const conds = ['1=1'];
+    const params = [];
+    if (filters.actionId) {
+        conds.push('e.action_id = ?');
+        params.push(filters.actionId);
+    }
+    if (filters.type) {
+        conds.push('e.type = ?');
+        params.push(filters.type);
+    }
+    if (filters.strength) {
+        conds.push('e.strength = ?');
+        params.push(filters.strength);
+    }
+    if (filters.sinceDateKey) {
+        // 必须按"证据自身产生时间"过滤，而不是它挂靠 action 的 date_key：
+        // 跨天完成的旧任务，其证据属于记录当天；无 action 的证据（评估/反思）同样要计入。
+        // created_at 是 UTC ISO，自然日边界需按配置时区换算。
+        conds.push('e.created_at >= ?');
+        params.push(startOfDateKey(filters.sinceDateKey, resolveTimezone(ctx)).toISOString());
+    }
+    const limit = Math.min(filters.limit ?? 100, 500);
+    const rows = ctx.db
+        .prepare(`SELECT e.* FROM evidence e WHERE ${conds.join(' AND ')} ORDER BY e.created_at DESC, e.rowid DESC LIMIT ${limit}`)
+        .all(...params);
+    return rows.map(rowToEvidence);
+}
+export function createAssessment(ctx, input) {
+    const id = newId();
+    const now = ts();
+    // 新建评估处于 EXPOSURE（刚接触），提交结果时升级
+    ctx.db
+        .prepare(`INSERT INTO assessments (id, action_id, goal_id, topic, level, method, passed, result, created_at, updated_at)
+              VALUES (?,?,?,?,'EXPOSURE',?,0,'{}',?,?)`)
+        .run(id, input.actionId ?? null, input.goalId ?? null, input.topic, input.method ?? null, now, now);
+    return { id, topic: input.topic };
+}
+/**
+ * 提交评估结果。规则（§22）：
+ * - Quiz 高分不等于完全掌握；level 由 Agent 按表现判定
+ * - 未通过 → 不升级 Knowledge State（返回给 Agent 决定重规划）
+ */
+export function submitAssessment(ctx, input) {
+    const row = ctx.db.prepare('SELECT * FROM assessments WHERE id=?').get(input.id);
+    if (!row)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Assessment not found: ${input.id}`);
+    const passed = !!input.passed;
+    ctx.db
+        .prepare('UPDATE assessments SET passed=?, level=?, result=?, updated_at=? WHERE id=?')
+        .run(passed ? 1 : 0, input.level, JSON.stringify({ ...(input.result ?? {}), level: input.level, passed }), ts(), input.id);
+    // 评估本身也是 evidence（QUIZ 类型）
+    addEvidence(ctx, {
+        type: 'QUIZ',
+        strength: passed ? 'AUTO_VERIFIED' : 'UNVERIFIED',
+        content: `Assessment "${row.topic}": ${input.level} ${passed ? 'PASSED' : 'FAILED'}`,
+        metadata: { assessmentId: input.id, level: input.level },
+    });
+    return {
+        assessment: { id: input.id, topic: row.topic, level: input.level, passed },
+        knowledgeStateUpdated: passed,
+    };
+}
+export function listAssessments(ctx, goalId, limit = 50) {
+    const rows = goalId
+        ? ctx.db.prepare('SELECT * FROM assessments WHERE goal_id=? ORDER BY created_at DESC LIMIT ?').all(goalId, limit)
+        : ctx.db.prepare('SELECT * FROM assessments ORDER BY created_at DESC LIMIT ?').all(limit);
+    return rows.map((r) => ({
+        id: r.id,
+        topic: r.topic,
+        method: r.method ?? undefined,
+        level: r.level,
+        passed: !!r.passed,
+        createdAt: r.created_at,
+    }));
+}
+export function createGrowthEvent(ctx, input) {
+    if (!input.evidenceIds?.length) {
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Growth Event requires at least one evidence id (no evidence-free personality judgments)');
+    }
+    const id = newId();
+    const dateKey = input.dateKey ?? todayIn(ctx);
+    ctx.db
+        .prepare(`INSERT INTO growth_events (id, date_key, title, description, domain, evidence_ids, goal_id, stage_id, tags, created_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?)`)
+        .run(id, dateKey, input.title, input.description ?? null, input.domain ?? 'OTHER', JSON.stringify(input.evidenceIds), input.goalId ?? null, input.stageId ?? null, JSON.stringify(input.tags ?? []), ts());
+    flagPassportDirty(ctx, 'growth event created');
+    writeAudit(ctx, { entityType: 'growth_event', entityId: id, after: input, reason: 'meaningful progress recorded' });
+    return getGrowthEvent(ctx, id);
+}
+export function getGrowthEvent(ctx, id) {
+    const r = ctx.db.prepare('SELECT * FROM growth_events WHERE id=?').get(id);
+    if (!r)
+        return null;
+    return {
+        id: r.id, dateKey: r.date_key, title: r.title, description: r.description ?? undefined,
+        domain: r.domain, evidenceIds: pj(r.evidence_ids, []),
+        goalId: r.goal_id ?? undefined, stageId: r.stage_id ?? undefined, tags: pj(r.tags, []),
+    };
+}
+export function listGrowthEvents(ctx, sinceDateKey, limit = 100) {
+    const rows = sinceDateKey
+        ? ctx.db.prepare('SELECT * FROM growth_events WHERE date_key >= ? ORDER BY date_key DESC, created_at DESC LIMIT ?').all(sinceDateKey, limit)
+        : ctx.db.prepare('SELECT * FROM growth_events ORDER BY date_key DESC, created_at DESC LIMIT ?').all(limit);
+    return rows.map((r) => getGrowthEvent(ctx, r.id));
+}
+// ---------- human versions（§9：有 Evidence 引用的稳定变化）----------
+export function createHumanVersion(ctx, title, description, evidenceIds) {
+    if (!evidenceIds?.length) {
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Human Version must reference evidence (V1.1 §9)');
+    }
+    const max = ctx.db.prepare('SELECT COALESCE(MAX(version), 0) AS v FROM human_versions').get();
+    const version = max.v + 1;
+    const id = newId();
+    ctx.db
+        .prepare('INSERT INTO human_versions (id, version, title, description, evidence_ids, created_at) VALUES (?,?,?,?,?,?)')
+        .run(id, version, title, description, JSON.stringify(evidenceIds), ts());
+    return { id, version };
+}
+export function listHumanVersions(ctx, limit = 20) {
+    return ctx.db
+        .prepare('SELECT * FROM human_versions ORDER BY version DESC LIMIT ?')
+        .all(limit);
+}

package/dist/core/goals.js

@@ -0,0 +1,188 @@
+import { writeAudit } from './context.js';
+import { newId, ts, pj } from '../shared/util.js';
+import { assertGoalTransition } from './stateMachine.js';
+import { DomainError, ErrorCodes } from '../shared/result.js';
+function rowToGoal(r) {
+    return {
+        id: r.id, title: r.title, why: r.why, desiredOutcome: r.desired_outcome,
+        successCriteria: pj(r.success_criteria, []), motivation: r.motivation ?? undefined,
+        startDate: r.start_date ?? undefined, targetDate: r.target_date ?? undefined,
+        status: r.status, dailyTimeBudgetMinutes: r.daily_time_budget_minutes ?? undefined,
+        createdAt: r.created_at, updatedAt: r.updated_at,
+    };
+}
+function rowToStage(r) {
+    return {
+        id: r.id, goalId: r.goal_id, title: r.title, objective: r.objective ?? undefined,
+        order: r.order_index, plannedStartDate: r.planned_start_date ?? undefined,
+        plannedEndDate: r.planned_end_date ?? undefined, status: r.status,
+        exitCriteria: pj(r.exit_criteria, []),
+    };
+}
+/** Goal 必须包含 why / desiredOutcome / successCriteria（V1.1 §18） */
+export function createGoalDraft(ctx, input) {
+    if (!input.title?.trim())
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Goal title is required');
+    if (!input.why?.trim())
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Goal must include why (V1.1 §18)');
+    if (!input.desiredOutcome?.trim())
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Goal must include desiredOutcome');
+    if (!Array.isArray(input.successCriteria) || input.successCriteria.length === 0)
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Goal must include at least one success criterion');
+    const id = newId();
+    const now = ts();
+    ctx.db
+        .prepare(`INSERT INTO goals (id, title, why, desired_outcome, success_criteria, motivation, start_date,
+       target_date, status, daily_time_budget_minutes, created_at, updated_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`)
+        .run(id, input.title.trim(), input.why.trim(), input.desiredOutcome.trim(), JSON.stringify(input.successCriteria), input.motivation ?? null, input.startDate ?? null, input.targetDate ?? null, 'DRAFT', input.dailyTimeBudgetMinutes ?? null, now, now);
+    const goal = getGoal(ctx, id);
+    writeAudit(ctx, { entityType: 'goal', entityId: id, after: goal, reason: 'create goal draft' });
+    return goal;
+}
+export function getGoal(ctx, id) {
+    const row = ctx.db.prepare('SELECT * FROM goals WHERE id=? AND deleted_at IS NULL').get(id);
+    return row ? rowToGoal(row) : null;
+}
+export function listGoals(ctx, statuses) {
+    const rows = statuses?.length
+        ? ctx.db
+            .prepare(`SELECT * FROM goals WHERE deleted_at IS NULL AND status IN (${statuses.map(() => '?').join(',')}) ORDER BY created_at`)
+            .all(...statuses)
+        : ctx.db.prepare('SELECT * FROM goals WHERE deleted_at IS NULL ORDER BY created_at').all();
+    return rows.map(rowToGoal);
+}
+export function getActiveGoals(ctx) {
+    return listGoals(ctx, ['ACTIVE']);
+}
+function updateGoalStatus(ctx, id, to, reason) {
+    const before = getGoal(ctx, id);
+    if (!before)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Goal not found: ${id}`);
+    assertGoalTransition(before.status, to);
+    ctx.db.prepare('UPDATE goals SET status=?, updated_at=? WHERE id=?').run(to, ts(), id);
+    const after = getGoal(ctx, id);
+    writeAudit(ctx, { entityType: 'goal', entityId: id, before, after, reason });
+    return after;
+}
+export function confirmGoal(ctx, id) {
+    return updateGoalStatus(ctx, id, 'CONFIRMED', 'user confirmed goal draft');
+}
+export function activateGoal(ctx, id) {
+    return updateGoalStatus(ctx, id, 'ACTIVE', 'goal activated (stage plan confirmed)');
+}
+export function pauseGoal(ctx, id) {
+    return updateGoalStatus(ctx, id, 'PAUSED', 'user paused goal');
+}
+export function resumeGoal(ctx, id) {
+    return updateGoalStatus(ctx, id, 'ACTIVE', 'user resumed goal');
+}
+/** 重大字段（why/outcome/criteria/deadline）修改记录审计；调用方（Agent）必须先获得用户确认 */
+export function updateGoal(ctx, id, input, reason = 'update goal') {
+    const before = getGoal(ctx, id);
+    if (!before)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Goal not found: ${id}`);
+    const next = {
+        title: input.title ?? before.title,
+        why: input.why ?? before.why,
+        desiredOutcome: input.desiredOutcome ?? before.desiredOutcome,
+        successCriteria: input.successCriteria ?? before.successCriteria,
+        motivation: input.motivation ?? before.motivation,
+        targetDate: input.targetDate !== undefined ? input.targetDate : before.targetDate,
+        dailyTimeBudgetMinutes: input.dailyTimeBudgetMinutes !== undefined ? (input.dailyTimeBudgetMinutes ?? undefined) : before.dailyTimeBudgetMinutes,
+    };
+    ctx.db
+        .prepare(`UPDATE goals SET title=?, why=?, desired_outcome=?, success_criteria=?, motivation=?,
+       target_date=?, daily_time_budget_minutes=?, updated_at=? WHERE id=?`)
+        .run(next.title, next.why, next.desiredOutcome, JSON.stringify(next.successCriteria), next.motivation ?? null, next.targetDate ?? null, next.dailyTimeBudgetMinutes ?? null, ts(), id);
+    const after = getGoal(ctx, id);
+    writeAudit(ctx, { entityType: 'goal', entityId: id, before, after, reason });
+    return after;
+}
+/** 创建 Stage Plan。确认 Goal 后才允许激活（由调用方控制顺序） */
+export function createStagePlan(ctx, input) {
+    const goal = getGoal(ctx, input.goalId);
+    if (!goal)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Goal not found: ${input.goalId}`);
+    const existing = listStages(ctx, input.goalId);
+    if (existing.length > 0)
+        throw new DomainError(ErrorCodes.ALREADY_EXISTS, 'Stage plan already exists for this goal');
+    if (!input.stages?.length)
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'Stage plan requires at least one stage');
+    const now = ts();
+    const insert = ctx.db.prepare(`INSERT INTO stages (id, goal_id, title, objective, order_index, planned_start_date, planned_end_date,
+     status, exit_criteria, created_at, updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?)`);
+    const ids = [];
+    const tx = ctx.db.transaction(() => {
+        input.stages.forEach((s, i) => {
+            const id = newId();
+            ids.push(id);
+            insert.run(id, input.goalId, s.title, s.objective ?? null, s.order ?? i + 1, s.plannedStartDate ?? null, s.plannedEndDate ?? null, 'PLANNED', JSON.stringify(s.exitCriteria ?? []), now, now);
+        });
+    });
+    tx();
+    writeAudit(ctx, { entityType: 'stage_plan', entityId: input.goalId, after: { stageCount: ids.length }, reason: 'create stage plan' });
+    return listStages(ctx, input.goalId);
+}
+export function listStages(ctx, goalId) {
+    const rows = ctx.db
+        .prepare('SELECT * FROM stages WHERE goal_id=? AND deleted_at IS NULL ORDER BY order_index')
+        .all(goalId);
+    return rows.map(rowToStage);
+}
+export function getStage(ctx, id) {
+    const row = ctx.db.prepare('SELECT * FROM stages WHERE id=?').get(id);
+    return row ? rowToStage(row) : null;
+}
+export function getCurrentStage(ctx, goalId) {
+    const rows = ctx.db
+        .prepare(`SELECT * FROM stages WHERE goal_id=? AND deleted_at IS NULL
+       AND status IN ('ACTIVE','PLANNED','DELAYED') ORDER BY order_index LIMIT 1`)
+        .all(goalId);
+    return rows[0] ? rowToStage(rows[0]) : null;
+}
+export function updateStage(ctx, input, reason = 'update stage') {
+    const before = getStage(ctx, input.id);
+    if (!before)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Stage not found: ${input.id}`);
+    ctx.db
+        .prepare(`UPDATE stages SET title=?, objective=?, order_index=?, planned_start_date=?, planned_end_date=?,
+       status=?, exit_criteria=?, updated_at=? WHERE id=?`)
+        .run(input.title ?? before.title, input.objective ?? before.objective ?? null, input.order ?? before.order, input.plannedStartDate ?? before.plannedStartDate ?? null, input.plannedEndDate ?? before.plannedEndDate ?? null, input.status ?? before.status, JSON.stringify(input.exitCriteria ?? before.exitCriteria), ts(), input.id);
+    const after = getStage(ctx, input.id);
+    writeAudit(ctx, { entityType: 'stage', entityId: input.id, before, after, reason });
+    return after;
+}
+/**
+ * Replan 后顺延后续 Stage 窗口（Core primitive，由 Agent 决策调用）。
+ *
+ * 关键约束：
+ * - COMPLETED / SKIPPED 是**历史记录**，日期与状态一律不改写，否则会伪造已完成阶段的窗口
+ * - ACTIVE 必须保持 ACTIVE，否则会丢失"当前阶段"信号（getCurrentStage 与 UI 高亮都依赖它）
+ * - PLANNED 顺延后标记为 DELAYED，用于记录"尚未开始就已滑档"
+ */
+export function shiftStagesFrom(ctx, goalId, fromStageId, days, reason) {
+    const stages = listStages(ctx, goalId);
+    const from = stages.find((s) => s.id === fromStageId);
+    if (!from)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Stage not found: ${fromStageId}`);
+    const addDaysToKey = (key) => {
+        if (!key)
+            return undefined;
+        const d = new Date(`${key}T00:00:00Z`);
+        d.setUTCDate(d.getUTCDate() + days);
+        return d.toISOString().slice(0, 10);
+    };
+    const FROZEN = ['COMPLETED', 'SKIPPED'];
+    for (const s of stages.filter((x) => x.order >= from.order)) {
+        if (FROZEN.includes(s.status))
+            continue;
+        updateStage(ctx, {
+            id: s.id,
+            plannedStartDate: addDaysToKey(s.plannedStartDate),
+            plannedEndDate: addDaysToKey(s.plannedEndDate),
+            status: s.status === 'PLANNED' ? 'DELAYED' : s.status,
+        }, reason);
+    }
+    return listStages(ctx, goalId);
+}