@dorokuma/herdsman-pi 0.14.1 → 0.14.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorokuma/herdsman-pi",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "description": "Pi extension bridge for Herdsman agent history.",
   "type": "module",
   "keywords": [

package/src/index.ts

@@ -7,7 +7,6 @@ export { logHerdsmanPi };
 export type { HerdsmanPiLogLevel } from "./logger.js";
 
 import {
-  type AgentContextListItem,
   type AgentEventWireRecord,
   type AgentOrchestratorChanged,
   type AgentOrchestratorWireState,
@@ -105,7 +104,6 @@ type HerdsmanState = {
   launchIdentity: LaunchIdentity | undefined;
   latestContext: AgentWorkspaceContextSnapshot | undefined;
   pendingEvents: AgentEventWireRecord[];
-  pinnedContext: AgentWorkspaceContextSnapshot | undefined;
   presentedEventIds: Set<number>;
   reconnectingFromOn: boolean;
   registrationInFlight: Promise<void> | undefined;
@@ -207,18 +205,24 @@ type HerdsmanState = {
    */
   wakeSkipLogReasons: Map<number, string>;
   /**
-   * Continuation drives already spent on the current unconsumed delivery.
+   * Continuation drives already spent, keyed by event id.
    *
-   * Reset when a delivery is handed over and when the unconsumed set empties, so
-   * the bound applies per delivery instead of accumulating for the session.
-   */
-  wakeContinuationAttempts: number;
-  /**
-   * Event content queued for a busy orchestrator. Injected through the
-   * `context` hook so the running turn sees the update without being
-   * interrupted.
+   * The bound is per event, never per delivery and never per session: an
+   * unrelated event being injected must not hand a stuck one a fresh budget. A
+   * session that keeps receiving new updates used to reset a shared counter at
+   * every injection, so the one id no run ever drained drove on unboundedly and
+   * `MAX_WAKE_CONTINUATION_ATTEMPTS` never fired — the loop that flooded the
+   * orchestrator session with empty turns.
+   *
+   * `MAX_WAKE_CONTINUATION_ATTEMPTS` is therefore a hard ceiling per id: the
+   * drive that reaches it writes that id off
+   * (`writeOffStrandedWakeDelivery`), and an id that still has drives left keeps
+   * both its copy and its count even when a sibling is written off next to it.
+   *
+   * An entry leaves the map with the id itself: acknowledged, dead-lettered,
+   * consumed (its copy reached the transcript), or a role/scope reset.
    */
-  wakeContext: { content: string; eventIds: number[] } | undefined;
+  wakeContinuationDrives: Map<number, number>;
   wakeRequested: boolean;
   wakeRequestedThroughEventId: number;
   wakeTimer: ReturnType<typeof setTimeout> | undefined;
@@ -285,18 +289,24 @@ export const WAKE_BUSY_SPIN_MS = 100;
  */
 export const WAKE_DEFERRED_TIMEOUT_MS = 5_000;
 /**
- * Upper bound on the continuation drives spent on one unconsumed wake delivery.
+ * Upper bound on the continuation drives spent on **one** unconsumed wake
+ * event id.
  *
  * Every drive costs a full agent run, so the budget is deliberately small: three
  * attempts already cover the drive that follows the settlement which missed Pi's
  * follow-up queue plus two retries after intervening runs that also ended before
  * their stop point, and five adds margin for a run that spent its stop point on
  * a tool call. Beyond that the cause is systemic — the runs keep ending early, so
- * starting another one could only produce another empty turn — and the delivery
- * is written off instead (`writeOffStrandedWakeDelivery`): the ids leave
- * `wakeAwaitingConsumption` and are acknowledged, which stops both the
+ * starting another one could only produce another empty turn — and that id is
+ * written off instead (`writeOffStrandedWakeDelivery`): it leaves
+ * `wakeAwaitingConsumption` and is acknowledged, which stops both the
  * continuation loop and the daemon's redelivery of the same event.
  *
+ * The bound is per event id (`wakeContinuationDrives`) and is never reset by a
+ * later injection: a session that keeps receiving new updates must not hand an
+ * already-stuck id a fresh ceiling, or the loop it was meant to stop continues
+ * for exactly the events that are stuck.
+ *
  * The trade-off is deliberate and asymmetric: losing one agent update is
  * recoverable (the agent is still there and its transcript can be read
  * directly), while an unbounded continuation loop floods the orchestrator
@@ -390,7 +400,6 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       launchIdentity: undefined,
       latestContext: undefined,
       pendingEvents: [],
-      pinnedContext: undefined,
       presentedEventIds: new Set(),
       reconnectingFromOn: false,
       registrationInFlight: undefined,
@@ -406,8 +415,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       wakeConsumptionObserved: new Set(),
       wakeSuppressedEventIds: new Set(),
       wakeSkipLogReasons: new Map(),
-      wakeContinuationAttempts: 0,
-      wakeContext: undefined,
+      wakeContinuationDrives: new Map(),
       wakeRequested: false,
       wakeRequestedThroughEventId: 0,
       wakeTimer: undefined,
@@ -458,15 +466,10 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       cancelWakeTimer();
       state.wakeRequested = false;
       state.wakeRequestedThroughEventId = 0;
-      // A wake queued for a busy orchestrator belongs to the role/scope that
-      // queued it: dropping it here keeps a stale event body out of the context
-      // of whatever session takes over next.
-      state.wakeContext = undefined;
     };
 
     const clearAgentContext = () => {
       state.latestContext = undefined;
-      state.pinnedContext = undefined;
       state.runActive = false;
     };
 
@@ -516,7 +519,8 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       state.wakeAwaitingConsumption.delete(eventId);
       state.wakeConsumptionObserved.delete(eventId);
       state.wakeSuppressedEventIds.delete(eventId);
-      if (state.wakeAwaitingConsumption.size === 0) state.wakeContinuationAttempts = 0;
+      // The id can no longer owe a drive, so its own budget leaves with it.
+      state.wakeContinuationDrives.delete(eventId);
     };
 
     /**
@@ -556,7 +560,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       state.wakeAwaitingConsumption.clear();
       state.wakeConsumptionObserved.clear();
       state.wakeSkipLogReasons.clear();
-      state.wakeContinuationAttempts = 0;
+      state.wakeContinuationDrives.clear();
     };
 
     const pruneAcknowledgedEvents = (ackedEventId: number | undefined) => {
@@ -958,10 +962,12 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         // of the same id out of the transcript.
         state.presentedEventIds.add(eventId);
       }
-      // Fresh budget for whatever is still awaiting consumption: the ids just
-      // written off are gone, and the ones that remain have not had their own
-      // MAX_WAKE_CONTINUATION_ATTEMPTS drives spent on them yet.
-      state.wakeContinuationAttempts = 0;
+      // The written-off ids can no longer owe a drive, so their budgets leave
+      // with them. Every id that is still awaiting consumption keeps its own
+      // budget: it has not spent its own MAX_WAKE_CONTINUATION_ATTEMPTS drives
+      // yet, and resetting it here is what used to let a sibling's fresh budget
+      // cover for an unrelated stuck id.
+      for (const eventId of eventIds) state.wakeContinuationDrives.delete(eventId);
       const stranded = eventIds
         .map((eventId) => state.unackedDelivered.get(eventId))
         .filter((event): event is AgentEventWireRecord => event !== undefined)
@@ -998,17 +1004,25 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
      *
      * Only consumption evidence writes a delivery off, so an intervening run that
      * ends before its stop point (error, user abort, a refused tool) leaves the
-     * next settlement driving again. That is bounded by
-     * MAX_WAKE_CONTINUATION_ATTEMPTS: starting runs cannot fix a cause that is
-     * not about the queue, so once the budget is spent the delivery is written
-     * off (released and acknowledged) instead of looping forever — see
+     * next settlement driving again. That bound is per event id and nothing
+     * resets it: starting runs cannot fix a cause that is not about the queue, so
+     * once an id's own budget is spent the id is written off (released and
+     * acknowledged) instead of looping forever — see
      * `writeOffStrandedWakeDelivery` for the trade-off.
      */
     const driveWakeContinuation = (ctx: PiContext) => {
       if (state.wakeAwaitingConsumption.size === 0) return;
       if (!pi.sendMessage) return;
       const eventIds = [...state.wakeAwaitingConsumption].sort((left, right) => left - right);
-      state.wakeContinuationAttempts += 1;
+      // Every id that is still waiting spends one drive of its own budget. The
+      // counters are keyed by event id and are never reset by an injection, so a
+      // delivery handed over later cannot buy an already-stuck id a fresh budget.
+      const spent: number[] = [];
+      for (const eventId of eventIds) {
+        const drives = (state.wakeContinuationDrives.get(eventId) ?? 0) + 1;
+        state.wakeContinuationDrives.set(eventId, drives);
+        spent.push(drives);
+      }
       try {
         pi.sendMessage(
           {
@@ -1020,21 +1034,27 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         );
         logHerdsmanPi(
           "info",
-          `[herdsman-pi] wake continuation driven eventIds=${eventIds[0] ?? 0}-${eventIds.at(-1) ?? 0} count=${eventIds.length} attempt=${state.wakeContinuationAttempts}`,
+          `[herdsman-pi] wake continuation driven eventIds=${eventIds[0] ?? 0}-${eventIds.at(-1) ?? 0} count=${eventIds.length} drives=${spent.join(",")}`,
         );
       } catch {
         logHerdsmanPi("warn", "[herdsman-pi] wake continuation refused by pi");
       }
-      if (state.wakeContinuationAttempts >= MAX_WAKE_CONTINUATION_ATTEMPTS) {
-        // This was the last drive the budget allows, and the queued copy is still
-        // undrained: the delivery is written off instead of being left pending
-        // forever. The ids are released from `wakeAwaitingConsumption` (no further
-        // run is started for them) and acknowledged, which is what stops the
-        // daemon from redelivering them every freshness window — the loop that
-        // used to flood the orchestrator session until manual sqlite surgery.
-        // Losing one update is the accepted cost; see
-        // `writeOffStrandedWakeDelivery`.
-        writeOffStrandedWakeDelivery([...state.wakeAwaitingConsumption], ctx);
+      // Only the ids whose own budget this drive spent are written off. A sibling
+      // that still has drives left keeps its copy in the queue and its count, so
+      // it is neither lost nor granted a fresh ceiling.
+      const exhausted = eventIds.filter(
+        (_eventId, index) => (spent[index] ?? 0) >= MAX_WAKE_CONTINUATION_ATTEMPTS,
+      );
+      if (exhausted.length > 0) {
+        // This was the last drive the id's own budget allows, and the queued copy
+        // is still undrained: the id is written off instead of being left
+        // pending forever. The ids are released from
+        // `wakeAwaitingConsumption` (no further run is started for them) and
+        // acknowledged, which is what stops the daemon from redelivering them
+        // every freshness window — the loop that used to flood the orchestrator
+        // session until manual sqlite surgery. Losing one update is the accepted
+        // cost; see `writeOffStrandedWakeDelivery`.
+        writeOffStrandedWakeDelivery(exhausted, ctx);
       }
     };
 
@@ -1233,11 +1253,17 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
           state.wakeTimer = undefined;
           state.wakeRequested = true;
           state.wakeRequestedThroughEventId = current.at(-1)?.eventId ?? 0;
-          // Dual-track injection: an idle orchestrator gets a triggered
-          // follow-up turn (immediate delivery), while a busy one is not
-          // interrupted — the same content is queued as a non-triggering
-          // follow-up and additionally exposed through the `context` hook so the
-          // running turn can already see it.
+          // Single-track injection: the wake content is handed to Pi exactly
+          // once, as the follow-up message below. An idle orchestrator gets a
+          // triggered follow-up turn (immediate delivery); a busy one is not
+          // interrupted and receives the same content as a queued,
+          // non-triggering follow-up that a later run drains out of the
+          // follow-up queue. There is deliberately no second copy on the
+          // `context` hook: a run that is busy cannot act on an early copy
+          // anyway, while a second copy is exactly what puts the same update
+          // into the session twice. So the transcript holds one entry per event
+          // id, and the continuation drive (see `driveWakeContinuation`) is what
+          // carries a queued copy that no run drained into the transcript.
           const orchestratorBusy = ctx.isIdle?.() === false;
           const wakeContent = formatAgentOutcomeUpdates(batchOutcomes);
           // Single line, injection path only: the decision that produced this
@@ -1278,17 +1304,17 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
             // `driveWakeContinuation`), and until the content is seen in the
             // transcript the delivery is neither acknowledged nor injected again.
             if (orchestratorBusy) {
+              // A freshly queued id starts its own continuation budget; an id that
+              // was already awaiting consumption (merged into this batch from an
+              // earlier injection) keeps the drives it already spent. Only a new
+              // id may get a fresh ceiling — never an unrelated one.
               for (const outcome of batchOutcomes) {
                 state.wakeAwaitingConsumption.add(outcome.eventId);
+                if (!state.wakeContinuationDrives.has(outcome.eventId)) {
+                  state.wakeContinuationDrives.set(outcome.eventId, 0);
+                }
               }
-              state.wakeContinuationAttempts = 0;
             }
-            // A queued (non-triggering) delivery keeps the content available to
-            // the current turn through the context hook until it is settled or
-            // superseded by the next injection.
-            state.wakeContext = orchestratorBusy
-              ? { content: wakeContent, eventIds: batchOutcomes.map((outcome) => outcome.eventId) }
-              : undefined;
             state.wakeForcedRelease = false;
             state.wakeDeferredSince = undefined;
             // Only expose the batch after the hidden context was accepted by pi. This
@@ -1528,7 +1554,6 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
           // already acked events are covered by the server cursor
           // (pruneAcknowledgedEvents below).
           state.deliveredBatch = undefined;
-          state.wakeContext = undefined;
         }
         // Otherwise the batch's wake turn is still in flight: keep it so the
         // settlement acknowledges it and the events are not re-presented.
@@ -1616,23 +1641,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
           state.currentScope.workspaceId === message.params.workspaceId
         ) {
           const next = message.params.context ?? undefined;
-          const retain = (snapshot: AgentWorkspaceContextSnapshot | undefined) =>
-            snapshot
-              ? {
-                  ...snapshot,
-                  agents: snapshot.agents.flatMap((agent) => {
-                    const nextAgents =
-                      next?.agents.filter((candidate) => candidate.paneId === agent.paneId) ?? [];
-                    if (nextAgents.length === 0) return [];
-                    const nextAgent = nextAgents.find(
-                      (candidate) => !agent.id || !candidate.id || agent.id === candidate.id,
-                    );
-                    return nextAgent ? [nextAgent] : [];
-                  }),
-                }
-              : undefined;
           state.latestContext = next;
-          state.pinnedContext = retain(state.pinnedContext);
         }
         return;
       }
@@ -1836,6 +1845,9 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         }
         for (const eventId of consumedEventIds) {
           state.wakeAwaitingConsumption.delete(eventId);
+          // Its copy reached the transcript, so the id owes no drive any more and
+          // its budget leaves with it.
+          state.wakeContinuationDrives.delete(eventId);
           // The content reached the transcript, so this id counts as presented from
           // now on: a daemon redelivery of it (it is still unacknowledged whenever
           // its batch was already dropped) must not inject the same update again.
@@ -1847,7 +1859,6 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
           // Only an id the daemon can still be told about is worth remembering.
           if (state.unackedDelivered.has(eventId)) state.wakeConsumptionObserved.add(eventId);
         }
-        if (state.wakeAwaitingConsumption.size === 0) state.wakeContinuationAttempts = 0;
       }
       if (message.role !== "assistant") return;
       const stopReason = stringValue(message.stopReason);
@@ -1886,63 +1897,25 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       // the next user message.
       if (state.runActive) return;
       state.runActive = true;
-      state.pinnedContext =
-        state.isOrchestrator && !state.deliveredBatch?.herdsmanTriggered
-          ? state.latestContext
-          : undefined;
     });
 
     pi.on("context", (event: { messages: PiAgentMessage[] }) => {
+      // The wake content rides the single follow-up track and is never pinned
+      // into the context here, so this hook injects nothing at all. What it
+      // still does is drop herdsman's own context/wake entries from the
+      // incoming list: a session replayed from disk can carry an old
+      // `[HERDSMAN AGENT CONTEXT]` preview (its truncated one-line reports
+      // repeatedly read as cut-off reports, and live board state is queried
+      // through herdr), so those entries are filtered out instead of being
+      // re-served to the model. The wake message itself
+      // (`herdsman-wake-context`, the full report text) is not filtered - it is
+      // the evidence the turn acts on.
       const messages = event.messages.filter((message) => !isNormalHerdsmanContext(message));
-      const additions: PiAgentMessage[] = [];
-      const snapshot = state.pinnedContext;
-      if (snapshot && snapshot.agents.length > 0) {
-        additions.push({
-          content: formatHiddenAgentContext({
-            agents: snapshot.agents,
-            workspaceId: snapshot.workspaceId,
-          }),
-          customType: "herdsman-agent-context",
-          display: false,
-          role: "custom",
-          timestamp: Date.now(),
-        });
-      }
-      // A wake queued for a busy orchestrator is not allowed to interrupt the
-      // running tool chain, so its content is additionally pinned to the current
-      // context: the orchestrator sees the child-agent outcome in this turn
-      // without a triggered follow-up. The entry is dropped again by
-      // isNormalHerdsmanContext, so at most one copy is present per call.
-      //
-      // `eventIds` mirrors what this turn actually presents (the freshly injected
-      // outcomes): events carried over in the delivery queue were already shown
-      // to the orchestrator in the turn that presented them, so they are not
-      // re-listed here. The queued follow-up message itself keeps the wider
-      // `details.eventIds` set (everything still unconfirmed).
-      //
-      // The pin is not a second delivery of the update: it makes the same queued
-      // copy visible early to the turn that is running, it is not written to the
-      // transcript, it is never acknowledged on its own, and it is not consumption
-      // evidence — only the hidden wake message's `message_end` is. So it may not be
-      // dropped in the name of "one copy only" either: it is the only way this turn
-      // ever sees the update.
-      const queuedWake = state.wakeContext;
-      if (queuedWake) {
-        additions.push({
-          content: queuedWake.content,
-          customType: "herdsman-wake-queued",
-          details: { eventIds: queuedWake.eventIds },
-          display: false,
-          role: "custom",
-          timestamp: Date.now(),
-        });
-      }
-      return additions.length === 0 ? { messages } : { messages: [...messages, ...additions] };
+      return { messages };
     });
 
     pi.on("agent_settled", async (_event: unknown, ctx: PiContext) => {
       state.runActive = false;
-      state.pinnedContext = undefined;
       // A wake delivered as a queued follow-up is drained only when a run reaches
       // its stop point. If the run that received it settled without draining it,
       // no further run exists to carry the update out: drive a continuation (up to
@@ -1960,7 +1933,6 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         state.wakeDeferredUntilSettled = false;
         state.wakeDeferredSince = undefined;
         state.wakeForcedRelease = false;
-        state.wakeContext = undefined;
         setHerdsmanUi(ctx);
         scheduleWake(ctx);
       };
@@ -2028,62 +2000,6 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
 
 export default createHerdsmanPiExtension();
 
-export function formatHiddenAgentContext(input: {
-  agents: AgentContextListItem[];
-  workspaceId: string;
-}): string {
-  return [
-    "[HERDSMAN AGENT CONTEXT]",
-    `Current Herdr workspace: ${input.workspaceId}`,
-    ...input.agents.map((agent) => {
-      const history = agent.history ?? {};
-      const identity = agentIdentityLabel({
-        agent: agent.agent ?? "unknown",
-        name: agent.name,
-      });
-      const paneId = agent.paneId ?? "unknown";
-      const status = agent.agentStatus ?? "unknown";
-      const prefix = `- ${identity} ${paneId} ${status}`;
-
-      const rawAgent = record(agent);
-      const tabTitleCandidate =
-        stringValue(rawAgent.terminalTitle) ?? stringValue(rawAgent.label);
-      const tabTitleCleaned =
-        tabTitleCandidate !== null ? sanitizeAndCleanContextText(tabTitleCandidate) : "";
-      const tabTitle =
-        tabTitleCleaned.length > 0 ? truncateSummary(tabTitleCleaned, 60) : null;
-
-      const rawHistory = record(history);
-      const lastAssistantRecord = record(history.lastAssistantMessage);
-      const timeCandidate =
-        lastAssistantRecord.timestamp ??
-        history.updatedAt ??
-        rawHistory.updatedAt ??
-        rawAgent.updatedAt ??
-        rawAgent.time;
-      const formattedTime = formatTimestamp(timeCandidate);
-
-      const assistantRaw = history.lastAssistantMessage?.text;
-      const assistantCleaned =
-        assistantRaw !== undefined && assistantRaw !== null
-          ? sanitizeAndCleanContextText(assistantRaw)
-          : "";
-      const assistantSummary =
-        assistantCleaned.length > 0 ? truncateSummary(assistantCleaned, 100) : null;
-
-      const segments = [
-        prefix,
-        tabTitle,
-        formattedTime,
-        assistantSummary,
-      ].filter((segment): segment is string => segment !== null && segment.length > 0);
-
-      return segments.join(" · ");
-    }),
-    "Use herdsman agent get/read if details are needed.",
-  ].join("\n");
-}
-
 export function formatHiddenAgentUpdates(events: AgentEventWireRecord[]): string {
   return [
     "[HERDSMAN AGENT UPDATES]",
@@ -2106,6 +2022,10 @@ export function formatHiddenAgentUpdates(events: AgentEventWireRecord[]): string
 function isNormalHerdsmanContext(message: PiAgentMessage): boolean {
   return (
     message.customType === "herdsman-agent-context" ||
+    // Defensive for session replay: older versions pinned a queued wake to the
+    // context hook under this customType. A replayed history may still carry
+    // those entries, and they are herdsman's own, so they are dropped from the
+    // incoming list like the agent-context ones (see the context hook).
     message.customType === "herdsman-wake-queued" ||
     contentIncludesMarker(message.content, "[HERDSMAN AGENT CONTEXT]")
   );
@@ -2185,32 +2105,3 @@ function sanitizeAndCleanContextText(value: string): string {
   return cleanContextText(sanitized);
 }
 
-function truncateSummary(value: string, limit = 100): string {
-  if (value.length <= limit) return value;
-  const maxSearch = Math.min(value.length, limit + 8);
-  const searchSlice = value.slice(0, maxSearch);
-  const lastSpaceIndex = searchSlice.search(/\s[^\s]*$/);
-  if (lastSpaceIndex >= limit - 20) {
-    return `${value.slice(0, lastSpaceIndex)}…`;
-  }
-  return `${value.slice(0, limit)}…`;
-}
-
-function formatTimestamp(value: unknown): string | null {
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    if (/^\d{2}:\d{2}:\d{2}$/.test(trimmed)) return trimmed;
-    if (/^\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(trimmed)) return trimmed;
-  }
-  if (!value) return null;
-  const date = value instanceof Date ? value : new Date(value as string | number);
-  if (Number.isNaN(date.getTime())) return null;
-  const pad = (n: number) => String(n).padStart(2, "0");
-  const month = pad(date.getMonth() + 1);
-  const day = pad(date.getDate());
-  const hours = pad(date.getHours());
-  const minutes = pad(date.getMinutes());
-  const seconds = pad(date.getSeconds());
-  return `${month}-${day} ${hours}:${minutes}:${seconds}`;
-}
-