@kynver-app/runtime 0.1.77 → 0.1.79

package/dist/cron/cron-env.d.ts

@@ -0,0 +1,21 @@
+export interface KynverCronEnv {
+    storePath: string;
+    statePath: string;
+    lockPath: string;
+    fireBaseUrl: string | null;
+    secret: string | null;
+    tickEnabled: boolean;
+    tickIntervalMs: number;
+    missedRunPolicy: "catch_up" | "skip";
+    maxCatchUpPerTick: number;
+    maxRetries: number;
+    retryBackoffMs: number;
+    inflightLeaseMs: number;
+}
+export declare function defaultKynverCronStorePath(): string;
+export declare function defaultKynverCronStatePath(storePath?: string): string;
+export declare function resolveKynverCronFireBaseUrl(): string | null;
+export declare function resolveKynverCronSecret(): string | null;
+/** Whether the connected-box daemon should run the local cron tick loop. */
+export declare function resolveKynverCronEnv(): KynverCronEnv;
+export declare function isKynverCronDaemonPrimary(env?: KynverCronEnv): boolean;

package/dist/cron/cron-fire.d.ts

@@ -0,0 +1,8 @@
+import type { CronFireResult, CronRegisteredJob } from "./cron-types.js";
+export declare function fireKynverCronJob(input: {
+    entry: CronRegisteredJob;
+    baseUrl: string;
+    secret: string;
+    jobId?: string | null;
+    fetchFn?: typeof fetch;
+}): Promise<CronFireResult>;

package/dist/cron/cron-lock.d.ts

@@ -0,0 +1,9 @@
+export interface CronTickLockInfo {
+    pid: number;
+    at: string;
+}
+export declare function tryAcquireCronTickLock(lockPath: string): {
+    acquired: boolean;
+    reason?: string;
+};
+export declare function releaseCronTickLock(lockPath: string): void;

package/dist/cron/cron-match.d.ts

@@ -0,0 +1,8 @@
+import type { CronJobSpec } from "./cron-types.js";
+export declare function isCronExpression(value: string): boolean;
+/** UTC 5-field cron match for a Date (minute resolution). */
+export declare function cronMatchesUtc(expr: string, at: Date): boolean;
+/** Next UTC fire at or strictly after `after` (minute resolution). */
+export declare function computeNextCronFireUtc(expr: string, after: Date): Date | null;
+export declare function computeInitialNextFire(spec: CronJobSpec, now: Date): string | null;
+export declare function advanceRecurringNextFire(spec: CronJobSpec, fromInclusive: Date): string | null;

package/dist/cron/cron-status.d.ts

@@ -0,0 +1,10 @@
+import type { KynverCronEnv } from "./cron-env.js";
+export interface KynverCronStatusReport {
+    primary: "kynver-cron-daemon" | "qstash" | "disabled";
+    env: Pick<KynverCronEnv, "storePath" | "statePath" | "tickEnabled" | "fireBaseUrl" | "missedRunPolicy" | "maxCatchUpPerTick" | "maxRetries">;
+    jobCount: number;
+    stateJobCount: number;
+    credentialsReady: boolean;
+    daemonPrimary: boolean;
+}
+export declare function buildKynverCronStatusReport(env?: KynverCronEnv): Promise<KynverCronStatusReport>;

package/dist/cron/cron-store.d.ts

@@ -0,0 +1,3 @@
+import type { CronRegisteredJob } from "./cron-types.js";
+export declare function parseCronStore(raw: string | null): CronRegisteredJob[];
+export declare function loadCronJobs(storePath?: string): Promise<CronRegisteredJob[]>;

package/dist/cron/cron-tick-cli.d.ts

@@ -0,0 +1,2 @@
+export declare function runCronStatusCli(json: boolean): Promise<void>;
+export declare function runCronTickCli(args: Record<string, string | boolean>): Promise<void>;

package/dist/cron/cron-tick-state.d.ts

@@ -0,0 +1,5 @@
+import type { CronTickJobState, CronTickStateFile } from "./cron-types.js";
+export declare function parseCronTickState(raw: string | null): CronTickStateFile;
+export declare function loadCronTickState(statePath: string): Promise<CronTickStateFile>;
+export declare function saveCronTickState(statePath: string, state: CronTickStateFile): Promise<void>;
+export declare function getOrCreateJobState(state: CronTickStateFile, providerScheduleId: string): CronTickJobState;

package/dist/cron/cron-tick.d.ts

@@ -0,0 +1,17 @@
+import type { KynverCronEnv } from "./cron-env.js";
+export interface CronTickResult {
+    enabled: boolean;
+    skipped?: string;
+    scanned: number;
+    due: number;
+    fired: number;
+    skippedJobs: number;
+    errors: number;
+    lockHeld?: boolean;
+}
+export declare function runKynverCronTick(opts?: {
+    env?: KynverCronEnv;
+    now?: Date;
+    fetchFn?: typeof fetch;
+    agentOsIdFilter?: string | null;
+}): Promise<CronTickResult>;

package/dist/cron/cron-types.d.ts

@@ -0,0 +1,44 @@
+/** Minimal mirror of server `KynverCronRegisteredJob` / `SchedulerJobSpec` for the local store. */
+export interface CronJobTarget {
+    agentOsId: string;
+    taskId?: string | null;
+    planId?: string | null;
+    planVersionId?: string | null;
+    goalId?: string | null;
+    projectId?: string | null;
+}
+export interface CronJobSpec {
+    kind: string;
+    scheduleKind: "cron" | "runAt";
+    cron?: string | null;
+    runAt?: string | null;
+    callbackPath: string;
+    payload?: Record<string, unknown> | null;
+    target: CronJobTarget;
+    description?: string | null;
+    dedupeKey?: string | null;
+}
+export interface CronRegisteredJob {
+    providerScheduleId: string;
+    spec: CronJobSpec;
+    registeredAt: string;
+    paused: boolean;
+}
+export interface CronTickJobState {
+    providerScheduleId: string;
+    nextFireAt: string | null;
+    lastFiredAt: string | null;
+    lastAttemptAt: string | null;
+    consecutiveFailures: number;
+    completedAt: string | null;
+    inflightUntil: string | null;
+}
+export interface CronTickStateFile {
+    version: 1;
+    jobs: Record<string, CronTickJobState>;
+}
+export interface CronFireResult {
+    ok: boolean;
+    status: number;
+    body: unknown;
+}

package/dist/dispatch.d.ts

@@ -6,6 +6,7 @@ export interface HarnessWorkerDispatchContext {
     instructionPolicyFingerprint: string | null;
     instructionPolicyEvidence: InstructionPolicyEvidenceSnapshot | null;
     memoryQualityCapture: HarnessMemoryQualityCaptureSnapshot | null;
+    memoryQualityPromptMarkdown: string | null;
     personaMarkdown: string | null;
     personaSlug: string | null;
     personaEvidence: PersonaContextEvidenceSnapshot | null;

package/dist/doctor/runtime-takeover-scheduler.d.ts

@@ -2,8 +2,10 @@ import type { DoctorCheck } from "./doctor.types.js";
 export type DeploymentSchedulerProvider = "qstash" | "kynver-cron" | "openclaw-cron";
 export interface RuntimeTakeoverSchedulerEnv {
     kynverSchedulerProvider?: string;
-    /** Local durable openclaw-cron bridge (`OPENCLAW_CRON_STORE_PATH`). */
+    /** Local durable cron store (`KYNVER_CRON_STORE_PATH` / legacy `OPENCLAW_CRON_STORE_PATH`). */
     openclawCronStorePath?: boolean;
+    /** `kynver daemon` runs the Kynver Cron tick loop (primary connected-box scheduler). */
+    kynverCronDaemonPrimary?: boolean;
     /** True when this process has QStash credentials (typical Kynver server deploy). */
     qstashTokenPresent?: boolean;
     /** Explicit hosted-deploy marker (`KYNVER_HOSTED_DEPLOYMENT=1|true|yes`). */

package/dist/doctor/runtime-takeover.probes.d.ts

@@ -26,8 +26,9 @@ export interface RuntimeTakeoverProbes {
         kynverHarnessRoot?: string;
         opusHarnessRoot?: string;
         kynverSchedulerProvider?: string;
-        /** Local durable openclaw-cron bridge (`OPENCLAW_CRON_STORE_PATH`). */
+        /** Local durable cron store (`KYNVER_CRON_STORE_PATH` / legacy alias). */
         openclawCronStorePath?: boolean;
+        kynverCronDaemonPrimary?: boolean;
         qstashTokenPresent?: boolean;
         kynverHostedDeployment?: boolean;
     };

package/dist/index.d.ts

@@ -45,6 +45,7 @@ export { assessOrphanWorktreeSafety } from "./cleanup-orphan-safety.js";
 export { isGeneratedHarnessPath, HARNESS_BUILD_CACHE_RELATIVE_PATHS } from "./cleanup-build-cache-paths.js";
 export { usage, main } from "./cli.js";
 export { reconcileRunsCli, reconcileStaleWorkers, type ReconcileStaleWorkersResult, type StaleWorkerReconcileOutcome } from "./stale-reconcile.js";
+export { repairMissingRunMetadata, collectFilesystemLiveRunKeys, isHarnessRunMetadataPath, runDirHasActiveRetentionSignals, workerDirHasActiveRetentionSignals, RUN_METADATA_ACTIVE_SIGNAL_MS, type RunMetadataRetentionOutcome, type RunMetadataRetentionResult, } from "./run-metadata-retention.js";
 export { reconcileWorkerMetadata, reconcileWorkerMetadataCli, type WorkerMetadataReconcileOutcome, type WorkerMetadataReconcileResult, } from "./worker-metadata-reconcile.js";
 export { canonicalWorkerDir, hasNestedRunsSegment, repairNestedRunsPath, resolveWorkerJsonPath, } from "./worker-metadata-paths.js";
 export { runDaemon } from "./daemon.js";