@qearlyao/familiar 0.2.3 → 0.2.4

package/dist/memory/lcm/context-transformer.js

@@ -1,5 +1,5 @@
 import { condense } from "./condense.js";
-import { createRawContextItems, estimateAgentMessageTokens, lcmRecordToAgentMessage, renderLcmRecordPartsForSummary, resolveFreshTailStartIndex, selectLcmCompactionCandidatePromptAware, } from "./context.js";
+import { createRawContextItems, estimateAgentMessageTokens, renderLcmRecordPartsForSummary, resolveFreshTailStartIndex, selectLcmCompactionCandidatePromptAware, } from "./context.js";
 import { indexLcmSummaries } from "./indexer.js";
 import { createSyntheticLcmSummaryMessage } from "./summarizer.js";
 const LCM_SUMMARY_OPEN_TAG = "<from_earlier>";
@@ -48,6 +48,7 @@ export class LcmContextTransformer {
                     signal,
                     model: options.model,
                     promptText,
+                    initialPressure: pressure,
                 });
             }
         }
@@ -76,7 +77,9 @@ export class LcmContextTransformer {
     }
     async serviceCompactionDebtForState(input) {
         for (let round = 0; input.state.compactionDebt > 0 && round < this.settings.maxRounds; round += 1) {
-            const pressure = this.evaluateCompactionPressure(input.state, input.model, input.promptText ?? "");
+            const pressure = round === 0 && input.initialPressure
+                ? input.initialPressure
+                : this.evaluateCompactionPressure(input.state, input.model, input.promptText ?? "");
             if (!pressure.candidate.shouldCompact) {
                 if (pressure.thresholdOverflowTokens > 0) {
                     const condensed = await this.condenseRuntimeSummaries({
@@ -262,8 +265,9 @@ export class LcmContextTransformer {
         this.lcmStore.db
             .transaction(() => {
             for (const insert of inserts) {
-                insert.item.recordId = this.lcmStore.insertRecord(insert.input);
-                insert.item.record = this.lcmStore.getRecord(insert.item.recordId);
+                const result = this.lcmStore.insertRecordReturningStored(insert.input);
+                insert.item.recordId = result.record.id;
+                insert.item.record = result.record;
             }
         })
             .immediate();
@@ -275,20 +279,7 @@ export class LcmContextTransformer {
         const items = [];
         for (const row of rows) {
             if (row.type === "raw") {
-                const record = this.lcmStore.getRecord(row.recordId);
-                if (!record) {
-                    console.error(`memory LCM context item dropped because record ${row.recordId} is missing`);
-                    continue;
-                }
-                const message = lcmRecordToAgentMessage(record);
-                items.push({
-                    type: "raw",
-                    id: row.fingerprint,
-                    recordId: record.id,
-                    record,
-                    message,
-                    tokens: estimateAgentMessageTokens(message),
-                });
+                // Raw history is owned by transcripts; legacy raw context rows must not replay it.
                 continue;
             }
             const summary = this.lcmStore.getSummary(row.summaryId);
@@ -359,8 +350,6 @@ function syncContextState(state, messages) {
         const replacement = rawById.get(item.id);
         if (replacement && !covered.has(item.id))
             next.push(replacement);
-        else if (item.recordId !== null && !covered.has(item.id))
-            next.push(item);
     }
     for (const item of rawItems) {
         if (!covered.has(item.id) && !next.some((existing) => existing.type === "raw" && existing.id === item.id)) {
@@ -390,8 +379,6 @@ function contextItemsForStorage(items) {
         const timestamp = item.message.timestamp;
         const happenedAt = typeof timestamp === "number" && Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : null;
         if (item.type === "raw") {
-            if (item.recordId !== null)
-                stored.push({ type: "raw", recordId: item.recordId, fingerprint: item.id, happenedAt });
             continue;
         }
         if (item.persistedSummaryId !== undefined) {
@@ -522,9 +509,10 @@ function assembleWithinBudget(state, settings, model) {
     const freshTail = state.items.slice(resolveFreshTailStartIndexForState(state.items, settings));
     const selected = new Set(freshTail);
     let tokens = sumItemTokens(freshTail);
+    const originalIndexes = new Map(state.items.map((item, index) => [item, index]));
     const summaries = state.items
         .filter((item) => item.type === "summary" && !selected.has(item))
-        .sort((a, b) => b.depth - a.depth || state.items.indexOf(b) - state.items.indexOf(a));
+        .sort((a, b) => b.depth - a.depth || (originalIndexes.get(b) ?? 0) - (originalIndexes.get(a) ?? 0));
     for (const item of summaries) {
         if (tokens + item.tokens > budget && selected.size > 0)
             continue;
@@ -587,7 +575,7 @@ function lcmRecordPartsFromAgentMessage(message) {
                 kind: "tool_result",
                 toolCallId: toolResult.toolCallId ?? "",
                 toolName: toolResult.toolName ?? "tool",
-                output: toolResult.details ?? textFromContent(toolResult.content),
+                output: textFromContent(toolResult.content),
                 ...(toolResult.isError ? { isError: true } : {}),
             },
         ];

package/dist/memory/lcm/context.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { scoreEvictable, tokenBag } from "./eviction-score.js";
+import { buildEvictionScoreContext, scoreEvictable, tokenBag } from "./eviction-score.js";
 const MESSAGE_OVERHEAD_TOKENS = 6;
 const RECORD_OVERHEAD_TOKENS = 4;
 const IMAGE_TOKEN_ESTIMATE = 1200;
@@ -167,9 +167,12 @@ function selectLeafChunk(items, leafChunkTokens, promptText, config) {
     const records = items.map((item) => item.record).filter((record) => !!record);
     if (records.length === 0)
         return selectOldestLeafChunk(items, leafChunkTokens);
+    const scoreContext = buildEvictionScoreContext(promptText, records);
+    if (!scoreContext)
+        return selectOldestLeafChunk(items, leafChunkTokens);
     const scored = targetRanges.map((range) => ({
         ...range,
-        score: range.items.reduce((total, item) => total + (item.record ? scoreEvictable(item.record, promptText, records) : 0), 0),
+        score: range.items.reduce((total, item) => total + (item.record ? scoreEvictable(item.record, promptText, records, scoreContext) : 0), 0),
     }));
     scored.sort((a, b) => a.score - b.score || a.startIndex - b.startIndex);
     return scored[0]?.items ?? [];
@@ -179,7 +182,7 @@ function createValidLeafRanges(items, leafChunkTokens) {
     for (let startIndex = 0; startIndex < items.length; startIndex += 1) {
         if (isToolResultContinuingPreviousToolCall(items, startIndex))
             continue;
-        const chunk = selectOldestLeafChunk(items.slice(startIndex), leafChunkTokens);
+        const chunk = selectOldestLeafChunkFromIndex(items, startIndex, leafChunkTokens);
         if (chunk.length === 0)
             continue;
         const chunkTokens = chunk.reduce((total, item) => total + item.tokens, 0);
@@ -194,9 +197,12 @@ function createValidLeafRanges(items, leafChunkTokens) {
     return ranges;
 }
 function selectOldestLeafChunk(items, leafChunkTokens) {
+    return selectOldestLeafChunkFromIndex(items, 0, leafChunkTokens);
+}
+function selectOldestLeafChunkFromIndex(items, startIndex, leafChunkTokens) {
     const chunk = [];
     let tokens = 0;
-    for (let index = 0; index < items.length; index += 1) {
+    for (let index = startIndex; index < items.length; index += 1) {
         const item = items[index];
         if (!item)
             continue;

package/dist/memory/lcm/eviction-score.js

@@ -4,34 +4,46 @@ export function tokenBag(text) {
         .split(/[^a-z0-9]+/)
         .filter((token) => token.length >= 2);
 }
-export function scoreEvictable(record, prompt, allRecords) {
+export function buildEvictionScoreContext(prompt, allRecords) {
     const promptTerms = tokenBag(prompt);
     if (promptTerms.length === 0)
-        return 0;
-    const recordTerms = tokenBag(record.text);
-    if (recordTerms.length === 0)
-        return 0;
-    const recordFreq = new Map();
-    for (const term of recordTerms)
-        recordFreq.set(term, (recordFreq.get(term) ?? 0) + 1);
+        return null;
     const promptUniqueTerms = new Set(promptTerms);
     const documentFrequencies = new Map();
+    const recordTerms = new Map();
     for (const candidate of allRecords) {
-        const candidateTerms = new Set(tokenBag(candidate.text));
+        const terms = tokenBag(candidate.text);
+        recordTerms.set(candidate, terms);
+        const candidateTerms = new Set(terms);
         for (const term of promptUniqueTerms) {
             if (candidateTerms.has(term))
                 documentFrequencies.set(term, (documentFrequencies.get(term) ?? 0) + 1);
         }
     }
-    const candidateCount = Math.max(0, allRecords.length);
+    return {
+        promptUniqueTerms,
+        documentFrequencies,
+        recordTerms,
+        candidateCount: Math.max(0, allRecords.length),
+    };
+}
+export function scoreEvictable(record, prompt, allRecords, context = buildEvictionScoreContext(prompt, allRecords)) {
+    if (!context)
+        return 0;
+    const recordTerms = context.recordTerms.get(record) ?? tokenBag(record.text);
+    if (recordTerms.length === 0)
+        return 0;
+    const recordFreq = new Map();
+    for (const term of recordTerms)
+        recordFreq.set(term, (recordFreq.get(term) ?? 0) + 1);
     let score = 0;
-    for (const term of promptUniqueTerms) {
+    for (const term of context.promptUniqueTerms) {
         const tf = recordFreq.get(term) ?? 0;
         if (tf <= 0)
             continue;
         const normalizedTf = tf / recordTerms.length;
-        const df = documentFrequencies.get(term) ?? 0;
-        const idf = Math.log((candidateCount + 1) / (df + 1) + 1);
+        const df = context.documentFrequencies.get(term) ?? 0;
+        const idf = Math.log((context.candidateCount + 1) / (df + 1) + 1);
         score += normalizedTf * idf;
     }
     return score;

package/dist/memory/lcm/indexer.js

@@ -8,11 +8,7 @@ export async function projectNormalizedLcmBatch(options) {
     }
     const storedRecords = [];
     for (const record of options.batch.records) {
-        const id = options.lcmStore.insertRecord(record);
-        const stored = options.lcmStore.getRecord(id);
-        if (!stored)
-            throw new Error(`Failed to read projected LCM record: ${id}`);
-        storedRecords.push(stored);
+        storedRecords.push(options.lcmStore.insertRecordReturningStored(record).record);
     }
     return {
         segmentIds,

package/dist/memory/lcm/normalize.js

@@ -59,7 +59,7 @@ export function normalizeChatRecords(chatRecords, options) {
                     kind: "tool_result",
                     toolCallId: record.event.toolCallId,
                     toolName: record.event.toolName,
-                    output: record.event.result,
+                    output: toolResultVisibleOutput(record.event.result),
                     ...(record.event.isError ? { isError: true } : {}),
                 },
             ];
@@ -191,6 +191,27 @@ function briefJson(value, maxLength = 160) {
     const compact = text.replace(/\s+/g, " ").trim();
     return compact.length > maxLength ? `${compact.slice(0, maxLength - 1)}...` : compact;
 }
+function toolResultVisibleOutput(result) {
+    if (!result || typeof result !== "object" || !("content" in result))
+        return result;
+    const content = result.content;
+    if (!Array.isArray(content))
+        return result;
+    return textFromToolResultContent(content);
+}
+function textFromToolResultContent(content) {
+    if (!Array.isArray(content))
+        return content;
+    return content
+        .map((item) => {
+        if (item && typeof item === "object" && item.type === "text") {
+            return item.text;
+        }
+        return "";
+    })
+        .filter((item) => typeof item === "string" && item.length > 0)
+        .join("\n");
+}
 function chatRecordSource(record, sourcePath) {
     const messageId = "messageId" in record && typeof record.messageId === "string"
         ? record.messageId

package/dist/memory/lcm/store.js

@@ -3,6 +3,7 @@ import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import Database from "better-sqlite3";
 import { normalizeFtsMatchQuery } from "../index/fts-query.js";
+import { runInTransaction } from "../util.js";
 import { readMeta, runLcmMigrations } from "./schema.js";
 export class LcmStore {
     db;
@@ -34,6 +35,9 @@ export class LcmStore {
         const raw = readMeta(this.db, "schema_version");
         return raw ? Number(raw) : null;
     }
+    computeRecordKey(input) {
+        return computeLcmRecordKey(input);
+    }
     ensureSegment(input) {
         const startedAt = input.startedAt ?? new Date().toISOString();
         this.db
@@ -68,6 +72,9 @@ export class LcmStore {
         return rows.map(segmentFromRow);
     }
     insertRecord(input) {
+        return this.insertRecordReturningStored(input).record.id;
+    }
+    insertRecordReturningStored(input) {
         const normalized = normalizeRecordInput(input);
         const runInsert = () => {
             this.ensureSegment({
@@ -76,14 +83,13 @@ export class LcmStore {
                 channelKey: normalized.channelKey,
                 startedAt: normalized.happenedAt,
             });
-            const existing = this.db
-                .prepare("SELECT id FROM lcm_records WHERE record_key = ?")
-                .get(normalized.recordKey);
+            const existing = this.db.prepare("SELECT * FROM lcm_records WHERE record_key = ?").get(normalized.recordKey);
             if (existing)
-                return existing.id;
-            return insertRecordPrepared(this.db, normalized);
+                return { record: recordFromRow(existing), inserted: false };
+            const inserted = insertRecordPrepared(this.db, normalized);
+            return { record: recordFromRow(inserted), inserted: true };
         };
-        return this.db.inTransaction ? runInsert() : this.db.transaction(runInsert).immediate();
+        return runInTransaction(this.db, runInsert);
     }
     getRecord(id) {
         const row = this.db.prepare("SELECT * FROM lcm_records WHERE id = ?").get(id);
@@ -132,7 +138,7 @@ export class LcmStore {
             this.insertSummarySources(id, sources);
             this.insertSummaryParents(id, parents);
         });
-        const result = this.db.inTransaction ? runInsert() : this.db.transaction(runInsert).immediate();
+        const result = runInTransaction(this.db, runInsert);
         return result;
     }
     getSummary(id) {
@@ -246,8 +252,14 @@ export class LcmStore {
                         .all(segmentId, retainDepth);
                     for (const summary of summaries) {
                         report.indexDeletes.push({ corpus: "lcm_summary", sourceId: lcmSummaryIndexSourceId(summary.id) });
-                        report.summaryFtsRowsDeleted += this.deleteSummaryFtsRow(summary.id);
                     }
+                    report.summaryFtsRowsDeleted += this.db
+                        .prepare(`DELETE FROM lcm_summaries_fts
+							 WHERE rowid IN (
+								SELECT id FROM lcm_summaries
+								WHERE segment_id = ? AND pinned = 0 AND depth < ?
+							 )`)
+                        .run(segmentId, retainDepth).changes;
                     report.summariesDeleted += this.db
                         .prepare("DELETE FROM lcm_summaries WHERE segment_id = ? AND pinned = 0 AND depth < ?")
                         .run(segmentId, retainDepth).changes;
@@ -257,8 +269,10 @@ export class LcmStore {
                 const records = this.db.prepare("SELECT id FROM lcm_records WHERE segment_id = ?").all(segmentId);
                 for (const record of records) {
                     report.indexDeletes.push({ corpus: "lcm_record", sourceId: lcmRecordIndexSourceId(record.id) });
-                    report.recordFtsRowsDeleted += this.deleteRecordFtsRow(record.id);
                 }
+                report.recordFtsRowsDeleted += this.db
+                    .prepare("DELETE FROM lcm_records_fts WHERE rowid IN (SELECT id FROM lcm_records WHERE segment_id = ?)")
+                    .run(segmentId).changes;
                 report.rawRecordsDeleted += this.db
                     .prepare("DELETE FROM lcm_records WHERE segment_id = ?")
                     .run(segmentId).changes;
@@ -318,20 +332,6 @@ export class LcmStore {
         }
         return map;
     }
-    deleteRecordFtsRow(id) {
-        const row = this.db.prepare("SELECT text_full FROM lcm_records WHERE id = ?").get(id);
-        if (!row)
-            return 0;
-        this.db.prepare("DELETE FROM lcm_records_fts WHERE rowid = ?").run(id);
-        return 1;
-    }
-    deleteSummaryFtsRow(id) {
-        const row = this.db.prepare("SELECT text_full FROM lcm_summaries WHERE id = ?").get(id);
-        if (!row)
-            return 0;
-        this.db.prepare("DELETE FROM lcm_summaries_fts WHERE rowid = ?").run(id);
-        return 1;
-    }
     snapshotSummariesForPrunedRecords(segmentId) {
         const summaries = this.db
             .prepare(`SELECT * FROM lcm_summaries
@@ -424,7 +424,10 @@ function insertRecordPrepared(db, normalized) {
     if (normalized.kind !== "boundary") {
         db.prepare("INSERT INTO lcm_records_fts(rowid, text_full) VALUES (?, ?)").run(id, normalized.text);
     }
-    return id;
+    const row = db.prepare("SELECT * FROM lcm_records WHERE id = ?").get(id);
+    if (!row)
+        throw new Error(`Failed to read inserted LCM record: ${id}`);
+    return row;
 }
 function normalizeSummaryInput(input) {
     const text = (input.text ?? "").trim();

package/dist/memory/operator.js

@@ -11,6 +11,7 @@ import { backfillFromChatLogs } from "./lcm/backfill.js";
 import { indexLcmRecords, indexLcmSummaries } from "./lcm/indexer.js";
 import { lcmRecordIndexSourceId, lcmSummaryIndexSourceId } from "./lcm/store.js";
 import { MemoryService } from "./service.js";
+import { runInTransaction } from "./util.js";
 export async function runMemoryOperator(config, argv) {
     const [command, ...args] = argv;
     if (!command || command === "--help" || command === "help") {
@@ -151,10 +152,7 @@ async function reindex(config, service, options, embeddingProvider, signal) {
         for (const corpus of corpora)
             deleteCorpus(service.memoryStore, corpus);
     };
-    if (service.memoryStore.db.inTransaction)
-        runDelete();
-    else
-        service.memoryStore.db.transaction(runDelete).immediate();
+    runInTransaction(service.memoryStore.db, runDelete);
     const indexer = options.force
         ? new ChunkIndexer({
             store: service.memoryStore,

package/dist/memory/service.js

@@ -1,5 +1,6 @@
 import { watch } from "node:fs";
 import { basename, resolve } from "node:path";
+import { isEnoent } from "../util/fs.js";
 import { __ambientDiaryInjectorTest, AmbientDiaryInjector } from "./diary/ambient-injector.js";
 import { DIARY_INDEX_FILE_RE, indexAllDiaryFiles, indexDiaryFile, removeDiaryFileIndex } from "./diary/indexer.js";
 import { ChunkIndexer } from "./index/chunk-indexer.js";
@@ -196,7 +197,4 @@ function parseIndexSourceId(value, prefix) {
     const id = Number(value.slice(prefix.length + 1));
     return Number.isInteger(id) && id > 0 ? id : null;
 }
-function isEnoent(error) {
-    return !!error && typeof error === "object" && "code" in error && error.code === "ENOENT";
-}
 export const __memoryServiceTest = __ambientDiaryInjectorTest;

package/dist/memory/tools.js

@@ -68,10 +68,6 @@ function makeMemoryRecallTool(deps) {
             return {
                 content: [{ type: "text", text: formatRecallResults(hits) }],
                 details: {
-                    query,
-                    scope,
-                    mode,
-                    limit,
                     resultCount: hits.length,
                     ids: hits.map((hit) => hit.id),
                 },

package/dist/memory/util.js

@@ -0,0 +1,6 @@
+export function positiveIntegerOrDefault(value, fallback) {
+    return value !== undefined && Number.isInteger(value) && value > 0 ? value : fallback;
+}
+export function runInTransaction(db, fn) {
+    return db.inTransaction ? fn() : db.transaction(fn).immediate();
+}

package/dist/models.js

@@ -95,6 +95,9 @@ export function createConfiguredModel(config) {
     }
     return resolveModel(ref, config);
 }
+export function resolveProviderSetting(records, provider, modelId) {
+    return records[`${provider}/${modelId}`] ?? records[provider];
+}
 export function resolveModelApiKey(config, model) {
     const configuredEnv = config.models.apiKeyEnvs[`${model.provider}/${model.id}`] ??
         config.models.apiKeyEnvs[model.provider] ??

package/dist/persona.js

@@ -1,23 +1,11 @@
 import { readFile } from "node:fs/promises";
-function isMissingFile(error) {
-    return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-async function readOptionalPersonaFile(path) {
-    try {
-        return await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (isMissingFile(error))
-            return null;
-        throw error;
-    }
-}
+import { readFileOrNull } from "./util/fs.js";
 export async function loadPersona(config) {
     const [soul, user, memory, inner] = await Promise.all([
         readFile(config.persona.soul, "utf8"),
         readFile(config.persona.user, "utf8"),
         readFile(config.persona.memory, "utf8"),
-        readOptionalPersonaFile(config.persona.inner),
+        readFileOrNull(config.persona.inner, "utf8"),
     ]);
     return { soul, user, memory, inner };
 }

package/dist/runtime.js

@@ -1,31 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { buildRecordBase, } from "./chat-log.js";
 import { promptAttachmentNotes } from "./inbound-attachments.js";
+import { formatLocalTimestamp } from "./util/time.js";
 function formatAuthor(authorName, authorId) {
     return authorName ? `${authorName} (uid:${authorId})` : `uid:${authorId}`;
 }
-function formatLocalTimestamp(ts) {
-    const date = new Date(ts);
-    if (Number.isNaN(date.getTime()))
-        return ts;
-    const offsetMinutes = -date.getTimezoneOffset();
-    const sign = offsetMinutes >= 0 ? "+" : "-";
-    const absolute = Math.abs(offsetMinutes);
-    const hours = Math.floor(absolute / 60);
-    const minutes = absolute % 60;
-    const offset = minutes === 0 ? `GMT${sign}${hours}` : `GMT${sign}${hours}:${String(minutes).padStart(2, "0")}`;
-    const local = [
-        date.getFullYear(),
-        String(date.getMonth() + 1).padStart(2, "0"),
-        String(date.getDate()).padStart(2, "0"),
-    ].join("-");
-    const time = [
-        String(date.getHours()).padStart(2, "0"),
-        String(date.getMinutes()).padStart(2, "0"),
-        String(date.getSeconds()).padStart(2, "0"),
-    ].join(":");
-    return `${local} ${time} ${offset}`;
-}
 function formatPromptRecord(record) {
     const text = record.text.trim() || "(no text)";
     const author = record.authorName?.trim()
@@ -365,7 +344,7 @@ export class ConversationRuntime {
     }
     async noteOutbound(options) {
         const text = options.text.trim();
-        if (!text && options.messageIds.length === 0)
+        if (!text && options.messageIds.length === 0 && !options.silent)
             return undefined;
         const record = {
             type: "outbound",

package/dist/scheduler.js

@@ -1,35 +1,9 @@
-import { appendFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, rename, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
+import { readFileOrNull } from "./util/fs.js";
+import { formatLocalTimestamp, toDate } from "./util/time.js";
+export { formatLocalTimestamp } from "./util/time.js";
 const stateWriteQueues = new Map();
-function toDate(value) {
-    if (value instanceof Date)
-        return value;
-    return new Date(value);
-}
-function formatOffset(date) {
-    const offsetMinutes = -date.getTimezoneOffset();
-    const sign = offsetMinutes >= 0 ? "+" : "-";
-    const absolute = Math.abs(offsetMinutes);
-    const hours = Math.floor(absolute / 60);
-    const minutes = absolute % 60;
-    return minutes === 0 ? `GMT${sign}${hours}` : `GMT${sign}${hours}:${String(minutes).padStart(2, "0")}`;
-}
-export function formatLocalTimestamp(value) {
-    const date = toDate(value);
-    if (Number.isNaN(date.getTime()))
-        return String(value);
-    const localDate = [
-        date.getFullYear(),
-        String(date.getMonth() + 1).padStart(2, "0"),
-        String(date.getDate()).padStart(2, "0"),
-    ].join("-");
-    const localTime = [
-        String(date.getHours()).padStart(2, "0"),
-        String(date.getMinutes()).padStart(2, "0"),
-        String(date.getSeconds()).padStart(2, "0"),
-    ].join(":");
-    return `${localDate} ${localTime} ${formatOffset(date)}`;
-}
 export function formatIdleDuration(ms) {
     if (!Number.isFinite(ms) || ms <= 0)
         return "0m";
@@ -53,9 +27,7 @@ export function buildHeartbeatInjectionText(options) {
     const body = options.body ??
         `hey~ been quiet for a bit. this is your time now.
 
-what you do with it is up to you — HEARTBEAT.md has the menu if you don't remember it. once you know the shape of it you don't have to re-read every fire, just trust what you remember and pick what fits.
-
-it's okay to sit one out, but only when that's actually the real answer — not when it's the easy one.`;
+what you do with it is up to you — HEARTBEAT.md has the menu if you don't remember it. once you know the shape of it you don't have to re-read every fire.`;
     return `<heartbeat local_time="${formatLocalTimestamp(nowDate)}" idle_duration="${formatIdleDuration(idleDurationMs)}" idle_minutes="${idleMinutes}">\n${body}\n</heartbeat>`;
 }
 function pad2(value) {
@@ -146,22 +118,16 @@ export function schedulerLogPath(dataDir, now = new Date()) {
     return resolve(dataDir, "scheduler", `${now.toISOString().slice(0, 10)}.jsonl`);
 }
 export async function loadSchedulerState(dataDir) {
-    const path = schedulerStatePath(dataDir);
-    try {
-        const raw = await readFile(path, "utf8");
-        const parsed = JSON.parse(raw);
-        return {
-            heartbeat: parsed.heartbeat && typeof parsed.heartbeat === "object" && !Array.isArray(parsed.heartbeat)
-                ? parsed.heartbeat
-                : undefined,
-            cron: parsed.cron && typeof parsed.cron === "object" && !Array.isArray(parsed.cron) ? parsed.cron : {},
-        };
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
-            return { cron: {} };
-        throw error;
-    }
+    const raw = await readFileOrNull(schedulerStatePath(dataDir), "utf8");
+    if (raw === null)
+        return { cron: {} };
+    const parsed = JSON.parse(raw);
+    return {
+        heartbeat: parsed.heartbeat && typeof parsed.heartbeat === "object" && !Array.isArray(parsed.heartbeat)
+            ? parsed.heartbeat
+            : undefined,
+        cron: parsed.cron && typeof parsed.cron === "object" && !Array.isArray(parsed.cron) ? parsed.cron : {},
+    };
 }
 export async function saveSchedulerState(dataDir, state) {
     const path = schedulerStatePath(dataDir);

package/dist/service.js

@@ -141,6 +141,26 @@ async function run(command, args, options) {
     }
     await execFileAsync(command, args);
 }
+async function runInteractive(command, args, options, errorPrefix) {
+    const currentPlatform = options.platform ?? platform();
+    if (options.runCommand) {
+        await options.runCommand(command, args);
+        return;
+    }
+    await new Promise((resolveRun, rejectRun) => {
+        const child = spawn(command, args, {
+            shell: currentPlatform === "win32",
+            stdio: "inherit",
+        });
+        child.on("exit", (code) => {
+            if (code === 0)
+                resolveRun();
+            else
+                rejectRun(new Error(`${errorPrefix} failed with exit code ${code ?? "unknown"}`));
+        });
+        child.on("error", rejectRun);
+    });
+}
 async function capture(command, args, options) {
     if (options.captureCommand)
         return options.captureCommand(command, args);
@@ -254,22 +274,12 @@ async function supervisorState(spec, options) {
         return "not-loaded";
     }
 }
-export async function upgradeFamiliar(options = {}) {
+export async function upgradeFamiliar(workspacePath, options = {}) {
     const currentPlatform = options.platform ?? platform();
     const npmCommand = currentPlatform === "win32" ? "npm.cmd" : "npm";
-    await new Promise((resolveUpgrade, rejectUpgrade) => {
-        const child = spawn(npmCommand, ["install", "-g", "@qearlyao/familiar@latest"], {
-            shell: currentPlatform === "win32",
-            stdio: "inherit",
-        });
-        child.on("exit", (code) => {
-            if (code === 0)
-                resolveUpgrade();
-            else
-                rejectUpgrade(new Error(`npm upgrade failed with exit code ${code ?? "unknown"}`));
-        });
-        child.on("error", rejectUpgrade);
-    });
+    const familiarCommand = currentPlatform === "win32" ? "familiar.cmd" : "familiar";
+    await runInteractive(npmCommand, ["install", "-g", "@qearlyao/familiar@latest"], options, "npm upgrade");
+    await runInteractive(familiarCommand, ["init", workspacePath], options, "workspace default refresh");
 }
 export function formatServiceResult(result) {
     return [result.title, ...result.details].join("\n");