project-logbook 0.3.3 → 0.4.0

package/dist/utils/date.d.ts

@@ -1,4 +1,21 @@
-/** Format a date value as a relative time string (e.g., "today, May 16, 2026"). */
+/**
+ * Format a date as absolute date and time (server-side).
+ * This is the primary format used in HTML data-date attributes.
+ * The client-side JavaScript will add the relative component (today, 2 days ago, etc).
+ * Format: "26 May 2026, 10:51"
+ * @param date - The date to format
+ * @returns Formatted date string with absolute date and time only
+ */
+export declare function formatAbsoluteDate(date: string | Date): string;
+/**
+ * Format a date as a consistent, human-readable format.
+ * Combines relative time (today, yesterday, 2 days ago) with absolute date and time.
+ * Format: "today, 26 May 2026, 10:51"
+ * This is for server-side rendering when client-side JS is not available.
+ * Normally, the client-side JS will update formatAbsoluteDate() output with this format.
+ * @param date - The date to format
+ * @returns Formatted date string with relative and absolute components
+ */
 export declare function formatRelativeDate(date: string | Date): string;
 /** Format a date value as YYYY-MM-DD. */
 export declare function formatIsoDate(value: string | Date): string;
@@ -6,3 +23,15 @@ export declare function formatIsoDate(value: string | Date): string;
 export declare function getMonthYear(date: string | Date): string;
 /** Get a short "HH:mmh" string for sorting/display based on dateEnd or dateStart. */
 export declare function getSortTime(dateStart: string | Date, dateEnd?: string | Date): string;
+/**
+ * Format a timestamp for metadata/footer display (build time).
+ * Alias for formatAbsoluteDate for clarity in build context.
+ */
+export declare function formatDateTimeForDisplay(date: string | Date): string;
+/**
+ * Format a date for RSS feed pubDate element.
+ * RSS requires RFC 822 date format: "Mon, 26 May 2026 10:51:00 GMT"
+ * @param date - The date to format
+ * @returns RFC 822 formatted date string
+ */
+export declare function formatDateTimeForRss(date: string | Date): string;

package/dist/utils/date.js

@@ -1,7 +1,42 @@
-/** Format a date value as a relative time string (e.g., "today, May 16, 2026"). */
-export function formatRelativeDate(date) {
+/**
+ * Parse and validate a date input (string or Date).
+ * Returns the Date object if valid, null if invalid.
+ */
+function parseDate(date) {
     const d = new Date(date);
-    if (isNaN(d.getTime())) {
+    return isNaN(d.getTime()) ? null : d;
+}
+/**
+ * Format a date as absolute date and time (server-side).
+ * This is the primary format used in HTML data-date attributes.
+ * The client-side JavaScript will add the relative component (today, 2 days ago, etc).
+ * Format: "26 May 2026, 10:51"
+ * @param date - The date to format
+ * @returns Formatted date string with absolute date and time only
+ */
+export function formatAbsoluteDate(date) {
+    const d = parseDate(date);
+    if (!d)
+        return 'unknown';
+    const day = d.getDate();
+    const month = d.toLocaleString('en-US', { month: 'short' });
+    const year = d.getFullYear();
+    const hours = String(d.getHours()).padStart(2, '0');
+    const minutes = String(d.getMinutes()).padStart(2, '0');
+    return `${day} ${month} ${year}, ${hours}:${minutes}`;
+}
+/**
+ * Format a date as a consistent, human-readable format.
+ * Combines relative time (today, yesterday, 2 days ago) with absolute date and time.
+ * Format: "today, 26 May 2026, 10:51"
+ * This is for server-side rendering when client-side JS is not available.
+ * Normally, the client-side JS will update formatAbsoluteDate() output with this format.
+ * @param date - The date to format
+ * @returns Formatted date string with relative and absolute components
+ */
+export function formatRelativeDate(date) {
+    const d = parseDate(date);
+    if (!d) {
         return 'unknown date';
     }
     const now = new Date();
@@ -9,16 +44,15 @@ export function formatRelativeDate(date) {
     const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24));
     const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });
     const relative = diffDays === 0 ? 'today' : rtf.format(-diffDays, 'day');
-    const absolute = d.toLocaleDateString('en-US', {
-        year: 'numeric',
-        month: 'long',
-        day: 'numeric',
-    });
+    // Format as "26 May 2026, 10:51"
+    const absolute = formatAbsoluteDate(d);
     return `${relative}, ${absolute}`;
 }
 /** Format a date value as YYYY-MM-DD. */
 export function formatIsoDate(value) {
-    const d = new Date(value);
+    const d = parseDate(value);
+    if (!d)
+        return 'invalid-date';
     const yyyy = d.getFullYear();
     const mm = String(d.getMonth() + 1).padStart(2, '0');
     const dd = String(d.getDate()).padStart(2, '0');
@@ -26,8 +60,8 @@ export function formatIsoDate(value) {
 }
 /** Get "Month Year" string for a date (e.g., "May 2026"). */
 export function getMonthYear(date) {
-    const d = new Date(date);
-    if (isNaN(d.getTime()))
+    const d = parseDate(date);
+    if (!d)
         return 'Unknown Date';
     return d.toLocaleDateString('en-US', {
         year: 'numeric',
@@ -36,12 +70,31 @@ export function getMonthYear(date) {
 }
 /** Get a short "HH:mmh" string for sorting/display based on dateEnd or dateStart. */
 export function getSortTime(dateStart, dateEnd) {
-    const dStart = new Date(dateStart);
-    const dEnd = dateEnd ? new Date(dateEnd) : null;
-    const date = dEnd && !isNaN(dEnd.getTime()) ? dEnd : dStart;
-    if (isNaN(date.getTime()))
+    const dStart = parseDate(dateStart);
+    const dEnd = dateEnd ? parseDate(dateEnd) : null;
+    const date = dEnd ? dEnd : dStart;
+    if (!date)
         return '--:--h';
     const hours = date.getHours().toString().padStart(2, '0');
     const minutes = date.getMinutes().toString().padStart(2, '0');
     return `${hours}:${minutes}h`;
 }
+/**
+ * Format a timestamp for metadata/footer display (build time).
+ * Alias for formatAbsoluteDate for clarity in build context.
+ */
+export function formatDateTimeForDisplay(date) {
+    return formatAbsoluteDate(date);
+}
+/**
+ * Format a date for RSS feed pubDate element.
+ * RSS requires RFC 822 date format: "Mon, 26 May 2026 10:51:00 GMT"
+ * @param date - The date to format
+ * @returns RFC 822 formatted date string
+ */
+export function formatDateTimeForRss(date) {
+    const d = parseDate(date);
+    if (!d)
+        return new Date().toUTCString();
+    return d.toUTCString();
+}

package/dist/utils/frontmatter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Normalizes a frontmatter field that may be a scalar string or a YAML list of strings.
+ * Used when displaying frontmatter fields like 'harness', 'llm', 'prompter' in the timeline.
+ *
+ * @param v - A frontmatter value (string, array of strings, or other type)
+ * @returns A display string joining multiple values with ' + ', or undefined if empty
+ */
+export declare function toDisplayString(v: unknown): string | undefined;
+/**
+ * Type guard: safely get a string field with optional fallback value.
+ * Used to defensively extract string fields from untyped YAML data.
+ *
+ * @param value - The value to check (may be unknown, string, or other type)
+ * @param fallback - Value to use if the input is not a string. If provided, return type is always string. If omitted, return type is string | undefined.
+ * @returns The value if it's a non-empty string, otherwise the fallback (or undefined if no fallback provided)
+ */
+export declare function asString(value: unknown): string | undefined;
+export declare function asString(value: unknown, fallback: string): string;
+/**
+ * Type guard: safely extract array of strings from a field that may be a string, array, or other type.
+ * Normalizes scalar strings to single-element arrays and filters out non-string array elements.
+ *
+ * @param value - The value to normalize (string, array, or other type)
+ * @returns Array of strings, or empty array if input is not convertible
+ */
+export declare function asStringArray(value: unknown): string[];

package/dist/utils/frontmatter.js

@@ -0,0 +1,37 @@
+/**
+ * Normalizes a frontmatter field that may be a scalar string or a YAML list of strings.
+ * Used when displaying frontmatter fields like 'harness', 'llm', 'prompter' in the timeline.
+ *
+ * @param v - A frontmatter value (string, array of strings, or other type)
+ * @returns A display string joining multiple values with ' + ', or undefined if empty
+ */
+export function toDisplayString(v) {
+    if (typeof v === 'string')
+        return v || undefined;
+    if (Array.isArray(v)) {
+        const joined = v.filter((x) => typeof x === 'string').join(' + ');
+        return joined || undefined;
+    }
+    return undefined;
+}
+export function asString(value, fallback) {
+    if (typeof value === 'string' && value)
+        return value;
+    return fallback;
+}
+/**
+ * Type guard: safely extract array of strings from a field that may be a string, array, or other type.
+ * Normalizes scalar strings to single-element arrays and filters out non-string array elements.
+ *
+ * @param value - The value to normalize (string, array, or other type)
+ * @returns Array of strings, or empty array if input is not convertible
+ */
+export function asStringArray(value) {
+    if (typeof value === 'string') {
+        return value ? [value] : [];
+    }
+    if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === 'string');
+    }
+    return [];
+}

package/dist/utils/fs.d.ts

@@ -11,3 +11,16 @@ export interface EntryMeta {
  * Filters for directories and parses index.md if it exists.
  */
 export declare function getLogbookEntries(logbookDir: string): Promise<EntryMeta[]>;
+/**
+ * Safely read a file if it exists, otherwise return an empty string.
+ * @param filePath - Path to the file to read
+ * @returns File contents if the file exists, otherwise empty string
+ */
+export declare function readFileIfExists(filePath: string): Promise<string>;
+/**
+ * Check if a file path exists, returning the path if it does.
+ * Useful for optional file resolution logic.
+ * @param filePath - Path to check
+ * @returns The path if it exists, otherwise null
+ */
+export declare function pathExistsOrNull(filePath: string): Promise<string | null>;

package/dist/utils/fs.js

@@ -36,3 +36,26 @@ export async function getLogbookEntries(logbookDir) {
     }
     return results;
 }
+/**
+ * Safely read a file if it exists, otherwise return an empty string.
+ * @param filePath - Path to the file to read
+ * @returns File contents if the file exists, otherwise empty string
+ */
+export async function readFileIfExists(filePath) {
+    if (await fs.pathExists(filePath)) {
+        return await fs.readFile(filePath, 'utf8');
+    }
+    return '';
+}
+/**
+ * Check if a file path exists, returning the path if it does.
+ * Useful for optional file resolution logic.
+ * @param filePath - Path to check
+ * @returns The path if it exists, otherwise null
+ */
+export async function pathExistsOrNull(filePath) {
+    if (await fs.pathExists(filePath)) {
+        return filePath;
+    }
+    return null;
+}

package/dist/utils/log-timeline.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Helpers for transforming technical log markdown into a timeline view.
+ */
+/**
+ * Parsed log entry with timestamp and message.
+ */
+export interface LogEntry {
+    timestamp: Date;
+    isoTimestamp: string;
+    message: string;
+}
+/**
+ * Timeline item for rendering - either a log entry or a gap indicator.
+ */
+export interface TimelineItem {
+    type: 'entry' | 'gap';
+    timestamp?: Date;
+    isoTimestamp?: string;
+    message?: string;
+    gapHours?: number;
+    showTime?: boolean;
+}
+/**
+ * Parse technical log markdown into structured log entries.
+ * @param logMarkdown - The raw markdown content of the technical log
+ * @returns Array of parsed log entries, or null if parsing fails
+ */
+export declare function parseLogMarkdown(logMarkdown: string): LogEntry[] | null;
+/**
+ * Transform log entries into a timeline with gap indicators.
+ * Shows ALL entries, but only displays timestamps for:
+ * - First entry
+ * - Entries after gaps >= threshold
+ * - Last entry
+ *
+ * This prevents timestamp clutter when LLM writes many entries in quick succession.
+ *
+ * @param entries - Parsed log entries (sorted chronologically)
+ * @param gapThresholdHours - Minimum gap in hours to show timestamp (default: 1)
+ * @returns Timeline items for rendering
+ */
+export declare function createTimelineFromEntries(entries: LogEntry[], gapThresholdHours?: number): TimelineItem[];
+/**
+ * Render timeline items as HTML.
+ * Creates a beautiful timeline that shows:
+ * - ALL log entries as messages
+ * - Timestamps only for significant moments (start, after gaps, end)
+ * - Gap indicators for breaks > threshold
+ *
+ * @param timeline - Timeline items to render
+ * @returns HTML string for the timeline
+ */
+export declare function renderTimelineHtml(timeline: TimelineItem[]): string;
+/**
+ * Get the last log entry from technical log markdown.
+ * Useful for displaying a "last logged" nudge in CLI output.
+ *
+ * @param logMarkdown - The raw markdown content of the technical log
+ * @returns The last LogEntry, or null if none found
+ */
+export declare function getLastLogEntry(logMarkdown: string): LogEntry | null;
+/**
+ * Main function to transform technical log markdown into timeline HTML.
+ * Falls back to plain markdown rendering if preprocessing fails.
+ *
+ * @param logMarkdown - The raw markdown content of the technical log
+ * @returns HTML string (timeline if successful, plain markdown otherwise)
+ */
+export declare function transformLogToTimeline(logMarkdown: string): Promise<string>;

package/dist/utils/log-timeline.js

@@ -0,0 +1,218 @@
+/**
+ * Helpers for transforming technical log markdown into a timeline view.
+ */
+/**
+ * Regex pattern to match log entries with ISO timestamps.
+ * Matches: "2026-05-27T14:17:02.250Z: Some message"
+ * Also matches bullet points: "- 2026-05-27T14:17:02.250Z: Some message"
+ */
+const LOG_ENTRY_REGEX = /^-?\s*(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)\s*:\s*(.+)$/;
+/**
+ * Parse technical log markdown into structured log entries.
+ * @param logMarkdown - The raw markdown content of the technical log
+ * @returns Array of parsed log entries, or null if parsing fails
+ */
+export function parseLogMarkdown(logMarkdown) {
+    if (!logMarkdown || typeof logMarkdown !== 'string') {
+        return null;
+    }
+    const lines = logMarkdown.split('\n');
+    const entries = [];
+    for (const line of lines) {
+        const match = line.match(LOG_ENTRY_REGEX);
+        if (match) {
+            const [, timestampStr, message] = match;
+            const timestamp = new Date(timestampStr);
+            if (isNaN(timestamp.getTime())) {
+                continue; // Skip invalid dates
+            }
+            entries.push({
+                timestamp,
+                isoTimestamp: timestampStr,
+                message: message.trim(),
+            });
+        }
+    }
+    // Sort entries chronologically
+    entries.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    return entries.length > 0 ? entries : null;
+}
+/**
+ * Transform log entries into a timeline with gap indicators.
+ * Shows ALL entries, but only displays timestamps for:
+ * - First entry
+ * - Entries after gaps >= threshold
+ * - Last entry
+ *
+ * This prevents timestamp clutter when LLM writes many entries in quick succession.
+ *
+ * @param entries - Parsed log entries (sorted chronologically)
+ * @param gapThresholdHours - Minimum gap in hours to show timestamp (default: 1)
+ * @returns Timeline items for rendering
+ */
+export function createTimelineFromEntries(entries, gapThresholdHours = 1) {
+    if (entries.length === 0) {
+        return [];
+    }
+    const timeline = [];
+    const gapThresholdMs = gapThresholdHours * 60 * 60 * 1000;
+    // Always show first entry with timestamp
+    timeline.push({
+        type: 'entry',
+        timestamp: entries[0].timestamp,
+        isoTimestamp: entries[0].isoTimestamp,
+        message: entries[0].message,
+        showTime: true,
+    });
+    // Process middle entries
+    for (let i = 1; i < entries.length - 1; i++) {
+        const prev = entries[i - 1];
+        const curr = entries[i];
+        const gapMs = curr.timestamp.getTime() - prev.timestamp.getTime();
+        const gapHours = (gapMs / gapThresholdMs) * gapThresholdHours;
+        if (gapHours >= gapThresholdHours) {
+            // Add gap indicator
+            timeline.push({
+                type: 'gap',
+                gapHours,
+            });
+            // Show this entry with timestamp after the gap
+            timeline.push({
+                type: 'entry',
+                timestamp: curr.timestamp,
+                isoTimestamp: curr.isoTimestamp,
+                message: curr.message,
+                showTime: true,
+            });
+        }
+        else {
+            // Show entry without timestamp (close to previous)
+            timeline.push({
+                type: 'entry',
+                message: curr.message,
+                showTime: false,
+            });
+        }
+    }
+    // Always show last entry
+    if (entries.length > 1) {
+        const last = entries[entries.length - 1];
+        const prev = entries[entries.length - 2];
+        const gapMs = last.timestamp.getTime() - prev.timestamp.getTime();
+        const gapHours = (gapMs / gapThresholdMs) * gapThresholdHours;
+        if (gapHours >= gapThresholdHours) {
+            // Add gap indicator before last entry
+            timeline.push({
+                type: 'gap',
+                gapHours,
+            });
+        }
+        // Last entry always shown with timestamp
+        timeline.push({
+            type: 'entry',
+            timestamp: last.timestamp,
+            isoTimestamp: last.isoTimestamp,
+            message: last.message,
+            showTime: true,
+        });
+    }
+    return timeline;
+}
+/**
+ * Format timestamp for display in timeline.
+ * Shows time in HH:MM format.
+ */
+function formatTime(timestamp) {
+    const hours = String(timestamp.getHours()).padStart(2, '0');
+    const minutes = String(timestamp.getMinutes()).padStart(2, '0');
+    return `${hours}:${minutes}`;
+}
+/**
+ * Escape HTML special characters.
+ */
+function escapeHtml(text) {
+    const htmlEscapes = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#39;',
+    };
+    return text.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+}
+/**
+ * Render timeline items as HTML.
+ * Creates a beautiful timeline that shows:
+ * - ALL log entries as messages
+ * - Timestamps only for significant moments (start, after gaps, end)
+ * - Gap indicators for breaks > threshold
+ *
+ * @param timeline - Timeline items to render
+ * @returns HTML string for the timeline
+ */
+export function renderTimelineHtml(timeline) {
+    if (timeline.length === 0) {
+        return '<p>No log entries available.</p>';
+    }
+    const itemsHtml = timeline
+        .map((item) => {
+        if (item.type === 'gap') {
+            const gapHours = item.gapHours?.toFixed(1) ?? '??';
+            return `
+          <li class="timeline-gap">
+            <span class="gap-indicator">
+              ⏸ ${gapHours}h break
+            </span>
+          </li>`;
+        }
+        if (item.type === 'entry' && item.message) {
+            const escapedMessage = escapeHtml(item.message);
+            if (item.showTime && item.timestamp && item.isoTimestamp) {
+                const time = formatTime(item.timestamp);
+                return `
+          <li class="timeline-entry has-time">
+            <time class="timeline-time" datetime="${escapeHtml(item.isoTimestamp)}">${time}</time>
+            <span class="timeline-message">${escapedMessage}</span>
+          </li>`;
+            }
+            else {
+                // Entry without timestamp - just the message
+                return `
+          <li class="timeline-entry no-time">
+            <span class="timeline-message">${escapedMessage}</span>
+          </li>`;
+            }
+        }
+        return '';
+    })
+        .join('');
+    return `<ul class="timeline">${itemsHtml}</ul>`;
+}
+/**
+ * Get the last log entry from technical log markdown.
+ * Useful for displaying a "last logged" nudge in CLI output.
+ *
+ * @param logMarkdown - The raw markdown content of the technical log
+ * @returns The last LogEntry, or null if none found
+ */
+export function getLastLogEntry(logMarkdown) {
+    const entries = parseLogMarkdown(logMarkdown);
+    return entries ? entries[entries.length - 1] : null;
+}
+/**
+ * Main function to transform technical log markdown into timeline HTML.
+ * Falls back to plain markdown rendering if preprocessing fails.
+ *
+ * @param logMarkdown - The raw markdown content of the technical log
+ * @returns HTML string (timeline if successful, plain markdown otherwise)
+ */
+export async function transformLogToTimeline(logMarkdown) {
+    const entries = parseLogMarkdown(logMarkdown);
+    if (!entries || entries.length === 0) {
+        // Fall back to plain markdown rendering
+        const fallbackContent = logMarkdown && logMarkdown.trim() ? escapeHtml(logMarkdown).replace(/\n/g, '<br>') : 'No log entries available.';
+        return '<div class="log-fallback">' + fallbackContent + '</div>';
+    }
+    const timeline = createTimelineFromEntries(entries);
+    return renderTimelineHtml(timeline);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-logbook",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "A command-line tool for project logbooks.",
   "workspaces": [
     "demo-app"
@@ -29,7 +29,7 @@
     "pre": "npm run format && npm run lint && npm run test && npm run build && npm run knip && npm run madge && npm run dev build && npm run dev lint",
     "next": "node scripts/create-ticket-from-backlog.js",
     "link": "npm run build && npm link",
-    "open": "npm run build && node scripts/open-and-view-dist.js"
+    "open": "npm run dev build && node scripts/open-and-view-dist.js"
   },
   "keywords": [
     "logbook",
@@ -42,6 +42,7 @@
     "@types/fs-extra": "^11.0.4",
     "@types/hast": "^3.0.4",
     "@types/node": "^25.7.0",
+    "@types/rss": "^0.0.32",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
     "@typescript-eslint/parser": "^8.32.1",
     "@vitest/coverage-v8": "^3.1.4",
@@ -65,6 +66,7 @@
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
     "remark-rehype": "^11.1.2",
+    "rss": "^1.2.2",
     "simple-git": "^3.36.0",
     "unified": "^11.0.5"
   }

package/src/templates/CONTRIBUTING.md

@@ -47,12 +47,21 @@ Only update the currently active logbook entry. Do not edit other existing entri
 When you finish writing `index.md`, **remove the boilerplate link line** that the template inserts:
 
 ### 3. Quality Assurance
-Before submitting your work, you MUST release the active entry and run the linter:
+Before finalizing your work, you should run the linter to verify there are no errors:
 ```bash
-logbook release
 logbook lint
 ```
-`logbook release` removes the `.logbook-active` lockfile. The linter will fail if the lockfile is still present, enforcing that no entry is left dangling in a committed state.
+
+You can also check the overall status of the logbook, configuration settings, and statistics (total tasks, done, and drafts) using:
+```bash
+logbook status
+```
+
+The linter will warn you if the lockfile `.logbook-active` is still present, which is expected during active development.
+
+Once the work is ready:
+- **If you are an AI agent**: Do not release the entry. Hand back to the prompter, who will review and run `logbook release`.
+- **If you are a human developer**: Run `logbook release` to remove the lockfile and finalize the entry.
 
 The linter enforces rules to be followed.
 

package/src/templates/index.md

@@ -3,24 +3,28 @@
 ticket: {{id}}
 # The title should be a human-readable description of the work
 title: {{title}}
-prompter: [PROMPTER]
-harness: [HARNESS]
-llm: [LLM]
-summary: [WRITE_SUMMARY_HERE]
+prompter: "[PROMPTER]"
+harness: "[HARNESS]"
+llm: "[LLM]"
+summary: "[WRITE_SUMMARY_HERE]"
 # Tags for categorizing the change (must be from allowed list in .project-logbook)
 tags: []
 # Workspace(s) this change affects (must match package.json workspaces; leave empty for single-project)
 # Example: workspaces: ["frontend", "shared"]
 workspaces: []
 # Set automatically by `logbook start`
-dateStart: [DATE_START]
+dateStart: "[DATE_START]"
 # Set automatically by `logbook release`
-dateEnd: [DATE_END]
+dateEnd: "[DATE_END]"
 ---
 
 ## Summary
 TODO: Write a polished, highly readable ticket summary that reads like an engaging technical narrative (similar to a well-written dev blog post).
 
+### Before You Start:
+- **Check `log.md`**: Review your technical log for all the decisions, errors, and pivots you recorded during implementation.
+- **Reference the log**: Use your real-time log entries as source material for the narrative — don't try to reconstruct from memory.
+
 ### Formatting & Style Rules:
 - **Maintain the narrative tone:** TODO: Keep the storytelling flair (e.g., describing how problems accumulated or how gaps surfaced), but stay strictly factual based on the provided changes.
 - **Add thematic headings:** TODO: Break the narrative down into logical chapters using Markdown headings (e.g., ### The Friction Points, ### The Fix, ### Closing the Gap).

package/src/templates/log.md

@@ -1,4 +1,9 @@
 # Technical Log: {{id}}-{{slug}}
 
+> **REMINDER**: Log your work in real-time using `logbook log "<message>"`. Don't wait until the end!
+> 
+> Log after every significant step: investigation, errors, decisions, code changes, test runs, etc.
+>
+
 ## Protocol
 - {{fullIso}}: Started investigation.