>((counts, fact) => {
+ if (fact.revertedAt === undefined) counts.set(fact.planId, (counts.get(fact.planId) ?? 0) + 1);
+ return counts;
+ }, new Map());
+ const completionFacts: CompletionFact[] = raw.completionFacts.map((fact) => {
+ const legacySegments = legacyExecutionRecords
+ .filter((record) =>
+ record.revertedAt === undefined
+ && (
+ record.completionFactId === fact.id
+ || (
+ record.completionFactId === undefined
+ && record.planId === fact.planId
+ && activeFactCountByPlan.get(fact.planId) === 1
+ )
+ )
+ )
+ .map(({ startAt, endAt }) => ({ startAt, endAt }));
+ return {
+ ...fact,
+ actualSegments: normalizeActualSegments(fact.actualSegments ?? legacySegments),
+ };
+ });
const plans: PlanRecord[] = raw.plans.map((plan) => {
- const activeFact = raw.completionFacts.find((fact) => fact.planId === plan.id && fact.revertedAt === undefined);
+ const activeFact = completionFacts.find((fact) => fact.planId === plan.id && fact.revertedAt === undefined);
const isCompleted = activeFact !== undefined;
const legacyExternalSchedule = raw.schemaVersion < 4 && plan.source === "learning-more" && !plan.sourceRef?.startsWith("week-up:");
const migratedTimeStatus = raw.schemaVersion < 6 && plan.source === "learning-more" && !isCompleted && plan.removedAt === undefined ? "unscheduled" as const : plan.timeStatus;
- const timeSegments = plan.timeSegments?.length
+ const baseTimeSegments = plan.timeSegments?.length
? plan.timeSegments
: migratedTimeStatus === "unscheduled"
? []
: [{ id: `${plan.id}:segment:0`, startAt: plan.startAt, endAt: plan.endAt, ...(activeFact ? { completedAt: activeFact.completedAt } : {}) }];
+ const timeSegments = baseTimeSegments.map((segment) => {
+ const legacyExecution = legacyExecutionRecords.find((record) =>
+ record.revertedAt === undefined
+ && record.planId === plan.id
+ && record.planSegmentId === segment.id
+ );
+ return legacyExecution
+ ? { ...segment, actualStartAt: legacyExecution.startAt, actualEndAt: legacyExecution.endAt }
+ : segment;
+ });
return {
...plan,
timeSegments,
@@ -1961,8 +1947,9 @@ export function migrateWeekUpState(value: unknown): WeekUpState {
});
return categories;
}, []);
+ const { executionRecords: _legacyExecutionRecords, completionFacts: _legacyCompletionFacts, ...rawState } = raw;
return {
- ...raw,
+ ...rawState,
schemaVersion: WEEK_UP_SCHEMA_VERSION,
attributeCategories,
projectCategories,
@@ -1976,7 +1963,7 @@ export function migrateWeekUpState(value: unknown): WeekUpState {
}),
learningMoreCourses: raw.schemaVersion < 5 ? [] : raw.learningMoreCourses ?? [],
learningMoreLessons: raw.schemaVersion < 5 ? [] : (raw.learningMoreLessons ?? []).map((lesson, index) => ({ ...lesson, scheduleItemId: lesson.scheduleItemId!, scheduledDate: lesson.scheduledDate!, order: lesson.order ?? index })),
- executionRecords: raw.executionRecords ?? [],
+ completionFacts,
dailySettlements: "dailySettlements" in raw && Array.isArray(raw.dailySettlements) ? raw.dailySettlements : [],
settlements: (raw.settlements ?? []).map(({ reflection: _legacyReflection, ...settlement }) => ({
...settlement,
diff --git a/web/tests/demo-source.test.mjs b/web/tests/demo-source.test.mjs
index 551bbe6..37c292b 100644
--- a/web/tests/demo-source.test.mjs
+++ b/web/tests/demo-source.test.mjs
@@ -213,6 +213,15 @@ test("keeps unscheduled plans outside time slots and uses one clickable time tic
assert.match(css, /\.dashboard-action-list \{[^}]*grid-template-columns: repeat\(2,minmax\(0,1fr\)\)/);
});
+test("shows untimed completion facts in the Timeline top area", async () => {
+ const page = await readFile(new URL("../app/page.tsx", import.meta.url), "utf8");
+ assert.doesNotMatch(page, /\{content === "schedule" && /);
+ assert.match(page, /content === "timeline" \? "未配置时间" : "待安排"/);
+ assert.match(page, /const countDescription = content === "timeline" \? "条完成记录未配置实际时间"/);
+ assert.match(page, /content === "timeline" \? "已完成但未记录实际时段"/);
+ assert.match(page, /readOnly=\{content === "timeline"\}/);
+});
+
test("does not hide non-overlapping calendar plans behind a fixed-count overflow ticket", async () => {
const page = await readFile(new URL("../app/page.tsx", import.meta.url), "utf8");
assert.doesNotMatch(page, /const visiblePlans = timedPlans\.slice\(0, 6\)/);
diff --git a/web/tests/view-projection.test.mjs b/web/tests/view-projection.test.mjs
index d137d43..c656cf7 100644
--- a/web/tests/view-projection.test.mjs
+++ b/web/tests/view-projection.test.mjs
@@ -75,3 +75,50 @@ test("keeps schedule projection separate from completed execution timeline", ()
[{ calendarSourceId: completedPlanId, scheduledDate: "2026-07-28", start: "10:00", end: "11:00" }],
);
});
+
+test("keeps an untimed completion visible at the top of its completion day", () => {
+ let sequence = 0;
+ const context = {
+ now: () => "2026-07-28T12:00:00+08:00",
+ id: (prefix) => `${prefix}-${++sequence}`,
+ };
+ let state = createEmptyWeekUpState();
+ state = dispatchWeekUp(state, {
+ type: "plan.create",
+ value: {
+ title: "Completed without actual time",
+ detail: "",
+ category: "Work",
+ startAt: "2026-07-29T17:00:00+08:00",
+ endAt: "2026-07-29T19:00:00+08:00",
+ goalIds: [],
+ rewards: [],
+ },
+ }, context).state;
+ const planId = state.plans[0].id;
+ state = dispatchWeekUp(state, {
+ type: "plan.complete",
+ id: planId,
+ completedAt: "2026-07-28T11:00:00+08:00",
+ }, context).state;
+
+ const view = projectWeekUpView(state, new Date("2026-07-28T12:00:00+08:00"));
+ assert.deepEqual(
+ view.timelinePlans.map(({ calendarSourceId, scheduledDate, start, end, timeStatus, completed }) => ({
+ calendarSourceId,
+ scheduledDate,
+ start,
+ end,
+ timeStatus,
+ completed,
+ })),
+ [{
+ calendarSourceId: planId,
+ scheduledDate: "2026-07-28",
+ start: "时间未配置",
+ end: "",
+ timeStatus: "unscheduled",
+ completed: true,
+ }],
+ );
+});
diff --git a/web/tests/week-up-domain.test.mjs b/web/tests/week-up-domain.test.mjs
index 1e7d747..1f690bc 100644
--- a/web/tests/week-up-domain.test.mjs
+++ b/web/tests/week-up-domain.test.mjs
@@ -818,6 +818,40 @@ test("round-trips a versioned backup", () => {
assert.throws(() => migrateWeekUpState({ schemaVersion: 99 }), /database_schema_unsupported/);
});
+test("folds legacy execution records into their completion fact", () => {
+ const h = harness();
+ let state = addAttribute(h, createEmptyWeekUpState());
+ state = addPlan(h, state, state.attributes[0].id);
+ const planId = state.plans[0].id;
+ state = h.run(state, {
+ type: "plan.complete",
+ id: planId,
+ completedAt: "2026-07-20T10:00:00+08:00",
+ });
+ const fact = state.completionFacts[0];
+ const { executionRecords: _removedExecutionRecords, ...currentWithoutExecutions } = state;
+ const migrated = migrateWeekUpState({
+ ...currentWithoutExecutions,
+ schemaVersion: 16,
+ completionFacts: [{ ...fact, actualSegments: undefined }],
+ executionRecords: [{
+ id: "legacy-execution",
+ planId,
+ startAt: "2026-07-20T09:10:00+08:00",
+ endAt: "2026-07-20T09:55:00+08:00",
+ source: "week-up",
+ recordedAt: fact.completedAt,
+ completionFactId: fact.id,
+ }],
+ });
+
+ assert.deepEqual(migrated.completionFacts[0].actualSegments, [{
+ startAt: "2026-07-20T09:10:00+08:00",
+ endAt: "2026-07-20T09:55:00+08:00",
+ }]);
+ assert.equal("executionRecords" in migrated, false);
+});
+
test("migrates legacy Learning MORE clock times back to time-unconfigured", () => {
const h = harness();
let state = addAttribute(h, createEmptyWeekUpState());
@@ -857,8 +891,8 @@ test("imports Learning MORE course tables and facts while Week UP owns schedule
assert.equal(state.plans[0].endAt, "2026-07-20T10:00:00+08:00");
assert.equal(state.plans[0].timeStatus, "scheduled");
assert.deepEqual(
- state.executionRecords.map(({ startAt, endAt, source }) => ({ startAt, endAt, source })),
- [{ startAt: "2026-07-20T02:12:00Z", endAt: "2026-07-20T03:47:00Z", source: "learning-more" }],
+ state.completionFacts[0].actualSegments,
+ [{ startAt: "2026-07-20T02:12:00Z", endAt: "2026-07-20T03:47:00Z" }],
);
assert.equal(state.plans[0].title, "概率论：条件概率");
assert.equal(state.plans[0].rewards[0].amount, 3);
@@ -906,7 +940,7 @@ test("keeps a directly completed overdue Learning MORE lesson on its original sc
assert.equal(state.plans[0].timeStatus, "unscheduled");
assert.deepEqual(state.plans[0].timeSegments ?? [], []);
assert.equal(state.completionFacts[0].completedAt, completion.occurredAt);
- assert.deepEqual(state.executionRecords, []);
+ assert.deepEqual(state.completionFacts[0].actualSegments, []);
assert.equal(totalXpForAttribute(state, attributeId), 2);
state = h.run(state, { type: "learning-more.import", facts: [completion] });
@@ -1208,12 +1242,10 @@ test("keeps a future schedule in place when an ordinary plan is completed early"
assert.equal(state.plans[0].endAt, "2026-07-21T19:00:00+08:00");
assert.equal(state.completionFacts[0].completedAt, "2026-07-20T16:00:00+08:00");
assert.deepEqual(
- state.executionRecords.map(({ planId: id, startAt, endAt, source }) => ({ id, startAt, endAt, source })),
+ state.completionFacts[0].actualSegments,
[{
- id: planId,
startAt: "2026-07-20T15:00:00+08:00",
endAt: "2026-07-20T16:00:00+08:00",
- source: "week-up",
}],
);
@@ -1263,17 +1295,15 @@ test("records Learning MORE actual time without moving its original schedule", (
assert.equal(state.completionFacts[0].planId, planId);
assert.equal(state.completionFacts[0].completedAt, "2026-07-20T16:00:00+08:00");
assert.deepEqual(
- state.executionRecords.map(({ planId: id, startAt, endAt, source }) => ({ id, startAt, endAt, source })),
+ state.completionFacts[0].actualSegments,
[{
- id: planId,
startAt: "2026-07-20T15:10:00+08:00",
endAt: "2026-07-20T16:00:00+08:00",
- source: "learning-more",
}],
);
});
-test("undoing one completed segment preserves other actual execution records", () => {
+test("undoing one completed segment preserves other segment actual time", () => {
const h = harness();
let state = addAttribute(h, createEmptyWeekUpState());
state = addPlan(h, state, state.attributes[0].id, {
@@ -1297,10 +1327,18 @@ test("undoing one completed segment preserves other actual execution records", (
completedAt: "2026-07-20T15:25:00+08:00",
actualSegment: { startAt: "2026-07-20T15:05:00+08:00", endAt: "2026-07-20T15:25:00+08:00" },
});
+ assert.deepEqual(state.completionFacts[0].actualSegments, [
+ { startAt: "2026-07-20T09:05:00+08:00", endAt: "2026-07-20T09:20:00+08:00" },
+ { startAt: "2026-07-20T15:05:00+08:00", endAt: "2026-07-20T15:25:00+08:00" },
+ ]);
state = h.run(state, { type: "plan.segment.undo", id: planId, segmentId: "first" });
- assert.equal(state.executionRecords.find((record) => record.planSegmentId === "first").revertedAt !== undefined, true);
- assert.equal(state.executionRecords.find((record) => record.planSegmentId === "second").revertedAt, undefined);
+ const first = state.plans[0].timeSegments.find((segment) => segment.id === "first");
+ const second = state.plans[0].timeSegments.find((segment) => segment.id === "second");
+ assert.equal(first.actualStartAt, undefined);
+ assert.equal(first.actualEndAt, undefined);
+ assert.equal(second.actualStartAt, "2026-07-20T15:05:00+08:00");
+ assert.equal(second.actualEndAt, "2026-07-20T15:25:00+08:00");
});
test("serializes load, dispatch, refresh, and replace through one store queue", async () => {