kankaku 0.8.0 → 0.8.2

package/dist/adapters/sync-runner.js

@@ -60,7 +60,11 @@ function isThrottled(state, trigger, now, minIntervalMs) {
 export async function runSync(deps, options = {}) {
     const startedAt = deps.clock.now();
     if (options.trigger !== undefined) {
-        const peek = deps.stateStore.read();
+        // Gated like every other read below: a state written for another hub
+        // says nothing about THIS hub, so neither its `logVersion` (which
+        // would otherwise skip the new hub's very first run until the next
+        // record is appended) nor its `lastRunAt` throttle may apply.
+        const peek = stateForTarget(deps, deps.stateStore.read());
         const currentVersion = deps.log.version?.();
         const versionUnchanged = currentVersion !== undefined && peek?.logVersion === currentVersion;
         if (versionUnchanged && peek?.lastError === undefined) {
@@ -75,10 +79,17 @@ export async function runSync(deps, options = {}) {
     try {
         lockAcquired = deps.stateStore.tryLock();
         if (!lockAcquired) {
-            const state = deps.stateStore.read();
+            const state = stateForTarget(deps, deps.stateStore.read());
             return { ...emptySummary(deps.clock.now() - startedAt, state?.syncedThrough), locked: true };
         }
         const state = deps.stateStore.read();
+        // A state from another hub is ignored wholesale, on EVERY path below
+        // (the summary, the error path, and the successful merge): its
+        // watermark and its hashes describe rows the configured hub does not
+        // have (mirrors `domain/sync-plan.ts#planSync`'s gate). `planSync`
+        // still receives the raw `state`, since it applies that same gate
+        // itself and its `target` comparison is what makes the run a full one.
+        const priorState = stateForTarget(deps, state);
         // Captured once, here, and persisted as-is below: this is the version
         // the tasks below were actually built from, not whatever the log might
         // become by the time an awaited push finishes.
@@ -93,10 +104,15 @@ export async function runSync(deps, options = {}) {
             // WorkSink implementations are expected never to throw, but this
             // runner must hold that guarantee even if one does.
             const message = error instanceof Error ? error.message : String(error);
-            const summary = emptySummary(deps.clock.now() - startedAt, state?.syncedThrough);
+            const summary = emptySummary(deps.clock.now() - startedAt, priorState?.syncedThrough);
             summary.skipped = plan.unchangedCount;
             summary.error = message;
-            persistError(deps, state, message, logVersionAtRead);
+            // `priorState`, never `state`: a throwing sink on the first run
+            // against a NEW hub must not carry the old hub's hashes and
+            // watermark over under the new target, or the next run would
+            // skip every task as "unchanged" (the exact bug 0.8.1 fixed on the
+            // successful path).
+            persistError(deps, priorState, message, logVersionAtRead);
             return summary;
         }
         const byId = new Map(plan.toSync.map((task) => [task.id, task]));
@@ -111,7 +127,7 @@ export async function runSync(deps, options = {}) {
         const unassigned = new Map();
         let uploaded = 0;
         let updated = 0;
-        let syncedThrough = state?.syncedThrough;
+        let syncedThrough = priorState?.syncedThrough;
         let stopError;
         // Whether at least one task was actually resolved (pushed or recorded
         // as failed) this run — as opposed to the run stopping on its very
@@ -147,13 +163,16 @@ export async function runSync(deps, options = {}) {
             }
             else {
                 // "error": a network/timeout/5xx/auth failure. Stop here — nothing
-                // after this point in the (chronologically sorted) results is
-                // considered resolved, so syncedThrough does not advance past it.
+                // after this point in the results is considered resolved. The
+                // results follow `plan.toSync`'s order (new work oldest-first,
+                // then corrections newest-first), and `syncedThrough` is a max
+                // over what WAS resolved, so stopping early can only leave it
+                // lower, never advance it past an unresolved task.
                 stopError = result.outcome.reason;
                 break;
             }
         }
-        const mergedHashes = { ...(state?.hashes ?? {}), ...Object.fromEntries(newHashes) };
+        const mergedHashes = { ...(priorState?.hashes ?? {}), ...Object.fromEntries(newHashes) };
         // G2: no longer window-bound — see `domain/sync-plan.ts#pruneHashes`'s
         // doc comment. `tasks` here is every task `buildTasks` currently knows
         // about (the full `readAll()`, not just this run's eligible/window
@@ -188,6 +207,11 @@ export async function runSync(deps, options = {}) {
             deps.stateStore.unlock();
     }
 }
+/** `state` when it was written against `deps.target`; `undefined` (as if there were no state at all) when it belongs to another hub. */
+function stateForTarget(deps, state) {
+    return state !== undefined && state.target === deps.target ? state : undefined;
+}
+/** Persist a failed run. `state` must already be gated by {@link stateForTarget}: what it carries is re-written under `deps.target`. */
 function persistError(deps, state, message, logVersionAtRead) {
     deps.stateStore.write({
         target: deps.target,

package/dist/domain/sync-plan.d.ts

@@ -14,7 +14,7 @@ import type { TaskView } from "./task-view.ts";
 export interface SyncState {
     /** High-watermark ISO timestamp: everything with `endedAt` at or before `syncedThrough - window` is considered done. `undefined` before the first successful sync. */
     syncedThrough?: string;
-    /** Content hash per task id (see {@link computeTaskContentHash}), pruned to the revisit window so the file stays small. */
+    /** Content hash per task id (see {@link computeTaskContentHash}), kept for as long as the task exists — never pruned by the revisit window (see {@link pruneHashes}). */
     hashes: Record<string, string>;
     /** The hub URL this state was synced against; a state written for a different URL is treated as absent (full sync). */
     target: string;
@@ -36,7 +36,8 @@ export interface SyncState {
      * `Clock`-based timestamp (ms) of the last real (non-short-circuited)
      * automatic sync attempt, persisted so the automatic path's throttle
      * (`KANKAKU_SYNC_MIN_INTERVAL_MINUTES`) holds across processes, not just
-     * within one. Never touched by a manual sync.
+     * within one. Written by every run that reaches the sink, manual or
+     * automatic; only the automatic path READS it to throttle itself.
      */
     lastRunAt?: number;
 }
@@ -49,7 +50,7 @@ export interface SyncPlanOptions {
     full?: boolean;
 }
 export interface SyncPlan {
-    /** Tasks whose content changed (or were never synced) and therefore need a request, in chronological (`endedAt`) order. */
+    /** Tasks whose content changed (or were never synced) and therefore need a request: new work in the window oldest-first, then corrections to rows the hub already holds, newest-first (see {@link planSync}). */
     toSync: TaskView[];
     /** How many eligible tasks were skipped because their stored hash already matched — no request needed for them. */
     unchangedCount: number;
@@ -115,8 +116,8 @@ export declare function planSync(tasks: TaskView[], state: SyncState | undefined
  * for "unchanged but I forgot"), so that window-based pruning made every
  * task older than the window look permanently changed, forever, the moment
  * its hash was first pruned: `/kankaku sync status` would report a
- * never-shrinking "changed outside the window" count that training taught
- * users to ignore (the bug this rewrite fixes).
+ * never-shrinking "changed outside the window" count that trained users
+ * to ignore it (the bug this rewrite fixes).
  *
  * Never pruning by window instead means `hashes` grows with the total
  * number of distinct tasks a directory has ever synced, not with time — an

package/dist/domain/sync-plan.js

@@ -110,7 +110,11 @@ export function planSync(tasks, state, options) {
         eligible = sorted.filter((task) => Date.parse(task.endedAt) > cutoff);
         outsideWindow = sorted.filter((task) => Date.parse(task.endedAt) <= cutoff);
     }
-    const hashes = state?.hashes ?? {};
+    // A state written for another hub contributes nothing, not even its
+    // hashes: the new hub has none of these rows, so a task that matched
+    // the OLD hub's hash must still be pushed. `isFullSync` alone only
+    // widened the window; without this gate every task looked "unchanged".
+    const hashes = state !== undefined && state.target === options.target ? state.hashes : {};
     const changed = (task) => hashes[task.id] !== computeTaskContentHash(task);
     // A row the hub ALREADY holds is corrected wherever it sits: the window
     // bounds how far back NEW work is looked for, never whether a known row
@@ -128,10 +132,10 @@ export function planSync(tasks, state, options) {
     const knownAndChanged = isFullSync ? allCorrections : allCorrections.slice(0, MAX_CORRECTIONS_PER_RUN);
     const correctionsDeferred = allCorrections.length - knownAndChanged.length;
     const toSync = [...eligible.filter(changed), ...knownAndChanged];
-    // R3: cheap, pure visibility into a task that changed but that this
-    // incremental run's window will not re-evaluate — see SyncPlan's doc
-    // comment. No extra work: `outsideWindow` is already computed above,
-    // this just re-applies the same hash-mismatch check to it.
+    // R3: cheap, pure visibility into a task this incremental run's window
+    // will not look at and that this hub has NEVER received (no stored hash)
+    // — see SyncPlan's doc comment. A known row that changed is a correction
+    // and is handled above, not reported here.
     const staleOutsideWindow = outsideWindow.filter((task) => hashes[task.id] === undefined);
     return { toSync, unchangedCount: eligible.length - eligible.filter(changed).length, isFullSync, staleOutsideWindow, correctionsDeferred };
 }
@@ -149,8 +153,8 @@ export function planSync(tasks, state, options) {
  * for "unchanged but I forgot"), so that window-based pruning made every
  * task older than the window look permanently changed, forever, the moment
  * its hash was first pruned: `/kankaku sync status` would report a
- * never-shrinking "changed outside the window" count that training taught
- * users to ignore (the bug this rewrite fixes).
+ * never-shrinking "changed outside the window" count that trained users
+ * to ignore it (the bug this rewrite fixes).
  *
  * Never pruning by window instead means `hashes` grows with the total
  * number of distinct tasks a directory has ever synced, not with time — an

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kankaku",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "pi extension that records agent work time per prompt, excluding waits for the user, with subagent linkage and task/session views",
   "license": "MIT",
   "author": "soyunninja",

package/src/adapters/sync-runner.ts

@@ -108,7 +108,11 @@ export async function runSync(deps: SyncRunnerDeps, options: { full?: boolean; t
   const startedAt = deps.clock.now();
 
   if (options.trigger !== undefined) {
-    const peek = deps.stateStore.read();
+    // Gated like every other read below: a state written for another hub
+    // says nothing about THIS hub, so neither its `logVersion` (which
+    // would otherwise skip the new hub's very first run until the next
+    // record is appended) nor its `lastRunAt` throttle may apply.
+    const peek = stateForTarget(deps, deps.stateStore.read());
     const currentVersion = deps.log.version?.();
     const versionUnchanged = currentVersion !== undefined && peek?.logVersion === currentVersion;
     if (versionUnchanged && peek?.lastError === undefined) {
@@ -125,11 +129,18 @@ export async function runSync(deps: SyncRunnerDeps, options: { full?: boolean; t
   try {
     lockAcquired = deps.stateStore.tryLock();
     if (!lockAcquired) {
-      const state = deps.stateStore.read();
+      const state = stateForTarget(deps, deps.stateStore.read());
       return { ...emptySummary(deps.clock.now() - startedAt, state?.syncedThrough), locked: true };
     }
 
     const state = deps.stateStore.read();
+    // A state from another hub is ignored wholesale, on EVERY path below
+    // (the summary, the error path, and the successful merge): its
+    // watermark and its hashes describe rows the configured hub does not
+    // have (mirrors `domain/sync-plan.ts#planSync`'s gate). `planSync`
+    // still receives the raw `state`, since it applies that same gate
+    // itself and its `target` comparison is what makes the run a full one.
+    const priorState = stateForTarget(deps, state);
     // Captured once, here, and persisted as-is below: this is the version
     // the tasks below were actually built from, not whatever the log might
     // become by the time an awaited push finishes.
@@ -144,10 +155,15 @@ export async function runSync(deps: SyncRunnerDeps, options: { full?: boolean; t
       // WorkSink implementations are expected never to throw, but this
       // runner must hold that guarantee even if one does.
       const message = error instanceof Error ? error.message : String(error);
-      const summary = emptySummary(deps.clock.now() - startedAt, state?.syncedThrough);
+      const summary = emptySummary(deps.clock.now() - startedAt, priorState?.syncedThrough);
       summary.skipped = plan.unchangedCount;
       summary.error = message;
-      persistError(deps, state, message, logVersionAtRead);
+      // `priorState`, never `state`: a throwing sink on the first run
+      // against a NEW hub must not carry the old hub's hashes and
+      // watermark over under the new target, or the next run would
+      // skip every task as "unchanged" (the exact bug 0.8.1 fixed on the
+      // successful path).
+      persistError(deps, priorState, message, logVersionAtRead);
       return summary;
     }
 
@@ -163,7 +179,7 @@ export async function runSync(deps: SyncRunnerDeps, options: { full?: boolean; t
     const unassigned = new Map<string, number>();
     let uploaded = 0;
     let updated = 0;
-    let syncedThrough = state?.syncedThrough;
+    let syncedThrough = priorState?.syncedThrough;
     let stopError: string | undefined;
     // Whether at least one task was actually resolved (pushed or recorded
     // as failed) this run — as opposed to the run stopping on its very
@@ -196,14 +212,17 @@ export async function runSync(deps: SyncRunnerDeps, options: { full?: boolean; t
         progressed = true;
       } else {
         // "error": a network/timeout/5xx/auth failure. Stop here — nothing
-        // after this point in the (chronologically sorted) results is
-        // considered resolved, so syncedThrough does not advance past it.
+        // after this point in the results is considered resolved. The
+        // results follow `plan.toSync`'s order (new work oldest-first,
+        // then corrections newest-first), and `syncedThrough` is a max
+        // over what WAS resolved, so stopping early can only leave it
+        // lower, never advance it past an unresolved task.
         stopError = result.outcome.reason;
         break;
       }
     }
 
-    const mergedHashes = { ...(state?.hashes ?? {}), ...Object.fromEntries(newHashes) };
+    const mergedHashes = { ...(priorState?.hashes ?? {}), ...Object.fromEntries(newHashes) };
     // G2: no longer window-bound — see `domain/sync-plan.ts#pruneHashes`'s
     // doc comment. `tasks` here is every task `buildTasks` currently knows
     // about (the full `readAll()`, not just this run's eligible/window
@@ -239,6 +258,12 @@ export async function runSync(deps: SyncRunnerDeps, options: { full?: boolean; t
   }
 }
 
+/** `state` when it was written against `deps.target`; `undefined` (as if there were no state at all) when it belongs to another hub. */
+function stateForTarget(deps: SyncRunnerDeps, state: ReturnType<SyncStateStore["read"]>): ReturnType<SyncStateStore["read"]> {
+  return state !== undefined && state.target === deps.target ? state : undefined;
+}
+
+/** Persist a failed run. `state` must already be gated by {@link stateForTarget}: what it carries is re-written under `deps.target`. */
 function persistError(deps: SyncRunnerDeps, state: ReturnType<SyncStateStore["read"]>, message: string, logVersionAtRead: string | number | undefined): void {
   deps.stateStore.write({
     target: deps.target,

package/src/domain/sync-plan.ts

@@ -17,7 +17,7 @@ import type { TaskView } from "./task-view.ts";
 export interface SyncState {
   /** High-watermark ISO timestamp: everything with `endedAt` at or before `syncedThrough - window` is considered done. `undefined` before the first successful sync. */
   syncedThrough?: string;
-  /** Content hash per task id (see {@link computeTaskContentHash}), pruned to the revisit window so the file stays small. */
+  /** Content hash per task id (see {@link computeTaskContentHash}), kept for as long as the task exists — never pruned by the revisit window (see {@link pruneHashes}). */
   hashes: Record<string, string>;
   /** The hub URL this state was synced against; a state written for a different URL is treated as absent (full sync). */
   target: string;
@@ -36,7 +36,8 @@ export interface SyncState {
    * `Clock`-based timestamp (ms) of the last real (non-short-circuited)
    * automatic sync attempt, persisted so the automatic path's throttle
    * (`KANKAKU_SYNC_MIN_INTERVAL_MINUTES`) holds across processes, not just
-   * within one. Never touched by a manual sync.
+   * within one. Written by every run that reaches the sink, manual or
+   * automatic; only the automatic path READS it to throttle itself.
    */
   lastRunAt?: number;
 }
@@ -51,7 +52,7 @@ export interface SyncPlanOptions {
 }
 
 export interface SyncPlan {
-  /** Tasks whose content changed (or were never synced) and therefore need a request, in chronological (`endedAt`) order. */
+  /** Tasks whose content changed (or were never synced) and therefore need a request: new work in the window oldest-first, then corrections to rows the hub already holds, newest-first (see {@link planSync}). */
   toSync: TaskView[];
   /** How many eligible tasks were skipped because their stored hash already matched — no request needed for them. */
   unchangedCount: number;
@@ -177,7 +178,11 @@ export function planSync(tasks: TaskView[], state: SyncState | undefined, option
     outsideWindow = sorted.filter((task) => Date.parse(task.endedAt) <= cutoff);
   }
 
-  const hashes = state?.hashes ?? {};
+  // A state written for another hub contributes nothing, not even its
+  // hashes: the new hub has none of these rows, so a task that matched
+  // the OLD hub's hash must still be pushed. `isFullSync` alone only
+  // widened the window; without this gate every task looked "unchanged".
+  const hashes = state !== undefined && state.target === options.target ? state.hashes : {};
   const changed = (task: TaskView): boolean => hashes[task.id] !== computeTaskContentHash(task);
   // A row the hub ALREADY holds is corrected wherever it sits: the window
   // bounds how far back NEW work is looked for, never whether a known row
@@ -195,10 +200,10 @@ export function planSync(tasks: TaskView[], state: SyncState | undefined, option
   const knownAndChanged = isFullSync ? allCorrections : allCorrections.slice(0, MAX_CORRECTIONS_PER_RUN);
   const correctionsDeferred = allCorrections.length - knownAndChanged.length;
   const toSync = [...eligible.filter(changed), ...knownAndChanged];
-  // R3: cheap, pure visibility into a task that changed but that this
-  // incremental run's window will not re-evaluate — see SyncPlan's doc
-  // comment. No extra work: `outsideWindow` is already computed above,
-  // this just re-applies the same hash-mismatch check to it.
+  // R3: cheap, pure visibility into a task this incremental run's window
+  // will not look at and that this hub has NEVER received (no stored hash)
+  // — see SyncPlan's doc comment. A known row that changed is a correction
+  // and is handled above, not reported here.
   const staleOutsideWindow = outsideWindow.filter((task) => hashes[task.id] === undefined);
 
   return { toSync, unchangedCount: eligible.length - eligible.filter(changed).length, isFullSync, staleOutsideWindow, correctionsDeferred };
@@ -218,8 +223,8 @@ export function planSync(tasks: TaskView[], state: SyncState | undefined, option
  * for "unchanged but I forgot"), so that window-based pruning made every
  * task older than the window look permanently changed, forever, the moment
  * its hash was first pruned: `/kankaku sync status` would report a
- * never-shrinking "changed outside the window" count that training taught
- * users to ignore (the bug this rewrite fixes).
+ * never-shrinking "changed outside the window" count that trained users
+ * to ignore it (the bug this rewrite fixes).
  *
  * Never pruning by window instead means `hashes` grows with the total
  * number of distinct tasks a directory has ever synced, not with time — an