@piagent/platform 1.5.5 → 1.6.1

package/packages/piagent-core/runtime/hooks/completion-hook.ts

@@ -6,8 +6,9 @@ import {
   acceptanceCriticalRecoveryProjection,
   applyAcceptanceRecoveryProvenance
 } from "../../extensions/acceptance-receipt.js";
+import { hasDurableContextEvidence } from "../../extensions/context-evidence.js";
 import type { TaskContract } from "../../extensions/guard-types.js";
-import { runtimeLifecycleMode, workingTreeEvidenceDigest } from "../../extensions/task-lifecycle.js";
+import { applyAssistedReadOnlyFinalHandoff, runtimeLifecycleMode, workingTreeEvidenceDigest } from "../../extensions/task-lifecycle.js";
 import { recordCompletionAudit } from "../../extensions/task-runtime-audit.js";
 import { workingTreeSnapshot } from "../../extensions/task-state.js";
 import { taskDeltaFilesFromSnapshot } from "../../extensions/task-contract-view.js";
@@ -18,8 +19,7 @@ import {
   looksLikeCompletionClaim,
   looksLikeIncompleteHandoff
 } from "../session/message-signals.ts";
-import { RuntimeSessionState } from "../session/runtime-state.ts";
-import type { ObservedTaskContext } from "../session/runtime-state.ts";
+import { RuntimeSessionState, type ObservedTaskContext } from "../session/runtime-state.ts";
 import type { RecoveryDecision } from "../recovery/recovery-policy.ts";
 import { buildHandoffProjection, handoffProjectionPath, writeHandoffProjection } from "../recovery/handoff-projection.ts";
 import { evaluateExactFinalOutputContract } from "../quality/exact-output-contract.ts";
@@ -177,7 +177,7 @@ export function registerCompletionHook(pi: ExtensionAPI, dependencies: Completio
     let task = flushObservedTaskContext(
       pi,
       ctx,
-      state.observedContext(ctx),
+      state.qualifiedTaskContext(ctx),
       maxManifestFiles,
       "context_observed_before_handoff"
     ) ?? activeTask(ctx);
@@ -187,7 +187,7 @@ export function registerCompletionHook(pi: ExtensionAPI, dependencies: Completio
     const completionClaim = looksLikeCompletionClaim(text);
     const incompleteHandoff = looksLikeIncompleteHandoff(text);
     if (task.trace.outcome !== "pending") return;
-    const readOnlyEvidenceObserved = task.changeMode === "read-only" && task.contextManifest.length > 0;
+    const readOnlyEvidenceObserved = (task.changeMode === "read-only" || task.mutationPolicy === "forbidden") && hasDurableContextEvidence(task);
     const latestExactVerifier = latestObservedVerification(task.verifyEvidence.filter((evidence) => evidence.matchedProfileCommand === true));
     const potentiallyFinalEvidence = task.observedChangedFiles.length > 0
       || latestExactVerifier?.exitCode === 0
@@ -203,6 +203,7 @@ export function registerCompletionHook(pi: ExtensionAPI, dependencies: Completio
     );
     let completionGate: CompletionGate | undefined;
     if (handoffAttempt) {
+      if (applyAssistedReadOnlyFinalHandoff(task, { durableReadEvidence: readOnlyEvidenceObserved, finalHandoffObserved: true }).changed) task = writeTask(ctx.cwd, task);
       let projected = completionProjection(ctx.cwd, task, currentDigests);
       const baseProjectedGate = evaluateGate(ctx.cwd, projected, currentDigests, currentDigest);
       const exactOutput = evaluateExactFinalOutputContract(projected, text, ctx.cwd);
@@ -298,7 +299,6 @@ export function registerCompletionHook(pi: ExtensionAPI, dependencies: Completio
         projected = withRecoveryProvenance(ctx, projected, projectedGate, currentDigests, null);
         task = writeTask(ctx.cwd, projected);
         observeTrajectorySync(ctx, syncTrajectory?.(ctx, task, { sourceHook: "completion" }), telemetry);
-        state.cacheTaskIdentity(ctx, task);
         state.clearPerformanceReview(task.taskRunId);
         state.clearObservedContext(ctx);
         activateBaseTools(ctx);
@@ -378,20 +378,20 @@ export function registerCompletionHook(pi: ExtensionAPI, dependencies: Completio
           ? [
             "Continue the same bounded task with one acceptance-proof repair pass.",
             ...criticalRecoveryGuidance,
-            "Add or correct focused in-scope tests for every missing critical obligation. Assert exact boundary partitions and requested error classes; if a focused test exposes a defect, repair the in-scope source before rerunning verification.",
+            "Add or correct focused tests for every missing critical obligation. Assert exact boundary partitions and requested error classes; if a focused test exposes a defect, repair the evidence-backed source before rerunning verification.",
             ...verifierInstructions(gate.missingVerifyCommands),
-            "Do not broaden task scope, repeat a failed hypothesis, expand permission, or perform an external action."
+            "Do not repeat a failed hypothesis, expand permission, or perform an external action."
           ]
           : [
-            "Continue the same bounded task with one targeted in-scope source repair, then run every exact configured verifier.",
+            "Continue the same bounded task with one targeted evidence-backed source repair, then run every exact configured verifier.",
             ...verifierInstructions(gate.missingVerifyCommands),
-            "Do not broaden task scope, repeat a failed hypothesis, expand permission, or perform an external action."
+            "Do not repeat a failed hypothesis, expand permission, or perform an external action."
           ]
-        : selectedRecovery.reasonCodes.includes("unknown-diagnostic-pass") || task.changeMode === "read-only"
+        : selectedRecovery.reasonCodes.includes("unknown-diagnostic-pass") || task.changeMode === "read-only" || task.mutationPolicy === "forbidden"
         ? [
             ...(gate.missingVerifyCommands.length > 0
               ? ["Run only the missing exact verifier commands against the current working tree.", ...verifierInstructions(gate.missingVerifyCommands)]
-              : ["Run one bounded diagnostic pass using targeted reads and report the concrete evidence or unknown."]),
+              : [(task.changeMode === "read-only" || task.mutationPolicy === "forbidden") && gate.missing.length > 0 && gate.missing.every((item) => /^completed work plan\b/i.test(item)) ? "Complete only the pending read-only review checkpoint, then re-emit the complete substantive assessment from the immediately preceding response; do not repeat repository reads or replace it with checkpoint evidence." : "Run one bounded diagnostic pass using targeted reads and report the concrete evidence or unknown."]),
             "Do not mutate project source, expand permission, or perform an external action."
           ]
         : [

package/packages/piagent-core/runtime/hooks/input-hook.ts

@@ -9,8 +9,10 @@ import { LONG_INPUT_CHARS } from "../runtime-limits.ts";
 import type { AuthorityResumeDecision } from "../policy/authority-resume-policy.ts";
 import { buildHandoffProjection, writeHandoffProjection } from "../recovery/handoff-projection.ts";
 import { buildContextPreflight, buildUsageSnapshot } from "../session/usage.ts";
+import { registerAdaptiveContextGovernor } from "../session/adaptive-context-governor.ts";
 import { activeTaskToolGroups, toolGroupsForPrompt } from "../tools/tool-groups.ts";
 import type { PiagentToolGroup } from "../tools/tool-groups.ts";
+import type { RuntimeSessionState } from "../session/runtime-state.ts";
 import {
   buildFreshCommand,
   chooseFreshWorkflow,
@@ -26,6 +28,7 @@ import {
 } from "../workflows/task-intake.ts";
 
 type InputHookDependencies = {
+  state: RuntimeSessionState;
   boilerplateCollapseChars: number;
   activeTask: (ctx: ExtensionContext) => TaskContract | undefined;
   authorityPolicy: (ctx: ExtensionContext, task: TaskContract) => AuthorityResumeDecision;
@@ -36,6 +39,11 @@ type InputHookDependencies = {
 };
 
 export function registerInputHook(pi: ExtensionAPI, dependencies: InputHookDependencies): void {
+  registerAdaptiveContextGovernor(pi, {
+    activeTask: dependencies.activeTask,
+    telemetry: dependencies.telemetry
+  });
+
   pi.on("input", async (event, ctx) => {
     const text = event.text.trim();
     if (!text || isFreshOrUtilityInput(text)) return { action: "continue" };
@@ -44,7 +52,14 @@ export function registerInputHook(pi: ExtensionAPI, dependencies: InputHookDepen
     }
 
     const taskSignal = classifyContextTask(text);
-    const activeTask = dependencies.activeTask(ctx);
+    const sessionTask = dependencies.activeTask(ctx);
+    if (sessionTask && sessionTask.trace.outcome !== "pending") dependencies.state.clearTaskBoundary(ctx, sessionTask.taskRunId);
+    else if (!sessionTask) {
+      const cachedTask = dependencies.state.taskIdentity(ctx);
+      if (cachedTask) dependencies.state.clearTaskBoundary(ctx, cachedTask.taskRunId);
+    }
+    const activeTask = sessionTask?.trace.outcome === "pending" ? sessionTask : undefined;
+    const turn = dependencies.state.beginTurn(ctx, taskSignal.promptHash);
     const authorityPolicy = activeTask?.trace.outcome === "pending" ? dependencies.authorityPolicy(ctx, activeTask) : undefined;
     let authorityHandoffReady = false;
     if (activeTask && authorityPolicy?.disposition === "new-attempt-required") {
@@ -79,6 +94,7 @@ export function registerInputHook(pi: ExtensionAPI, dependencies: InputHookDepen
       : promptGroups);
     dependencies.telemetry(ctx, {
       event: "user_input",
+      turnId: turn.turnId,
       source: event.source,
       promptHash: taskSignal.promptHash,
       promptChars: taskSignal.promptChars,

package/packages/piagent-core/runtime/hooks/session-hooks.ts

@@ -4,6 +4,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import type { TaskContract } from "../../extensions/guard-types.js";
 import { RuntimeSessionState } from "../session/runtime-state.ts";
 import type { ObservedTaskContext } from "../session/runtime-state.ts";
+import { confirmContextDelivery, contextDeliveryIdFromDetails } from "../context/context-delivery.ts";
 
 type TelemetryWriter = (ctx: ExtensionContext, payload: Record<string, unknown>) => void;
 
@@ -39,6 +40,20 @@ export function registerSessionHooks(pi: ExtensionAPI, dependencies: SessionHook
     flushObservedTaskContext
   } = dependencies;
 
+  pi.on("message_start", async (event, ctx) => {
+    const message = event.message as unknown as { role?: unknown; details?: unknown };
+    if (message.role !== "custom") return;
+    const deliveryId = contextDeliveryIdFromDetails(message.details);
+    if (!deliveryId) return;
+    confirmContextDelivery(pi, ctx, deliveryId, {
+      state,
+      maxManifestFiles,
+      activeTask: (deliveryContext) => activeTask(deliveryContext.cwd, deliveryContext.sessionManager.getSessionId()),
+      flushObservedTaskContext,
+      telemetry
+    });
+  });
+
   pi.on("session_info_changed", async (event, ctx) => {
     const sessionId = ctx.sessionManager.getSessionId();
     const task = activeTask(ctx.cwd, sessionId);
@@ -58,6 +73,7 @@ export function registerSessionHooks(pi: ExtensionAPI, dependencies: SessionHook
 
   pi.on("turn_end", async (event, ctx) => {
     const message = event.message as unknown as { usage?: unknown; stopReason?: unknown; role?: unknown };
+    const task = activeTask(ctx.cwd, ctx.sessionManager.getSessionId());
     telemetry(ctx, {
       event: "turn_end",
       turnIndex: event.turnIndex,
@@ -65,9 +81,13 @@ export function registerSessionHooks(pi: ExtensionAPI, dependencies: SessionHook
       role: message.role,
       stopReason: message.stopReason,
       usage: message.usage,
-      contextUsage: ctx.getContextUsage()
+      contextUsage: ctx.getContextUsage(),
+      taskId: task?.taskId,
+      taskRunId: task?.taskRunId,
+      taskOutcome: task?.trace.outcome
     });
     dependencies.onTurnEnd?.(ctx);
+    if (task && task.trace.outcome !== "pending") state.clearTaskBoundary(ctx, task.taskRunId);
   });
 
   pi.on("agent_settled", async (_event, ctx) => {
@@ -96,7 +116,7 @@ export function registerSessionHooks(pi: ExtensionAPI, dependencies: SessionHook
     flushObservedTaskContext(
       pi,
       ctx,
-      state.observedContext(ctx),
+      state.qualifiedTaskContext(ctx),
       maxManifestFiles,
       "context_observed_before_shutdown"
     );

package/packages/piagent-core/runtime/hooks/session-start-hook.ts

@@ -21,6 +21,8 @@ import { buildContextPreflight, buildUsageSnapshot } from "../session/usage.ts";
 import { toolResultCaptureRoot } from "../session/tool-result-compaction.ts";
 import { ensureTaskAuthorityResumePolicy } from "../policy/authority-resume-policy.ts";
 import { buildHandoffProjection, writeHandoffProjection } from "../recovery/handoff-projection.ts";
+import { refreshPristineRuntimeTaskVerification } from "../recovery/pristine-task-policy-refresh.ts";
+import { refreshLegacyHiddenWorkspaceEvidenceCoverage } from "../recovery/task-evidence-coverage-refresh.ts";
 import { activeTaskToolGroups } from "../tools/tool-groups.ts";
 import type { PiagentToolGroup } from "../tools/tool-groups.ts";
 import { observeTrajectorySync } from "../trajectory/trajectory-observability.ts";
@@ -40,6 +42,7 @@ type SessionStartHookDependencies = {
   resolveTaskAny: (cwd: string, reference: string) => TaskContract | undefined;
   bindTask: (cwd: string, sessionId: string, sessionName: string | undefined, task: TaskContract) => unknown;
   writeTask: (cwd: string, task: TaskContract) => TaskContract;
+  appendTrace: (cwd: string, payload: Record<string, unknown>) => void;
   capabilityState: (ctx: ExtensionContext) => { ok: boolean; reason?: string; repinned?: string };
   permissionProfile: (ctx: ExtensionContext, profile: ProjectProfile) => { mode: string; warning?: string };
   legacyProjectWarning: (cwd: string) => string | undefined;
@@ -138,9 +141,107 @@ export function registerSessionStartHook(pi: ExtensionAPI, dependencies: Session
       resumedTask = dependencies.writeTask(ctx.cwd, resumedTask);
       dependencies.bindTask(ctx.cwd, sessionId, sessionName, resumedTask);
     }
+    const capabilityState = dependencies.capabilityState(ctx);
+    if (resumedTask?.trace.outcome === "pending"
+      && authorityPolicy?.disposition === "resume-pinned"
+      && capabilityState.ok) {
+      // Re-read from the durable session binding immediately before the
+      // synchronous pristine-tree check and write. This prevents an earlier
+      // session-start projection from overwriting newer same-process task
+      // evidence or work-plan state.
+      const latestTask = dependencies.activeTask(ctx.cwd, sessionId);
+      if (latestTask?.taskRunId === resumedTask.taskRunId) {
+        resumedTask = latestTask;
+        let refreshTask = latestTask;
+        // Coverage reconciliation must precede resume inspection. Otherwise a
+        // path newly visible to the evidence collector looks like a task delta
+        // and can incorrectly block a valid dirty-task resume.
+        const coverage = refreshLegacyHiddenWorkspaceEvidenceCoverage(ctx.cwd, refreshTask);
+        if (coverage.refreshed) {
+          try {
+            resumedTask = dependencies.writeTask(ctx.cwd, coverage.task);
+            refreshTask = resumedTask;
+            try {
+              dependencies.appendTrace(ctx.cwd, {
+                event: "task_evidence_coverage_expanded",
+                taskId: resumedTask.taskId,
+                taskRunId: resumedTask.taskRunId,
+                sessionId,
+                sessionName,
+                reason: coverage.reason,
+                addedPathCount: coverage.addedPaths.length,
+                addedPathExamples: coverage.addedPaths.slice(0, 20),
+                retainedMutationPathCount: coverage.retainedMutationPaths.length,
+                retainedMutationPathExamples: coverage.retainedMutationPaths.slice(0, 20),
+                ambiguousPathCount: coverage.ambiguousPaths.length,
+                ambiguousPathExamples: coverage.ambiguousPaths.slice(0, 20),
+                previousBaselineDigest: coverage.previousBaselineDigest,
+                nextBaselineDigest: coverage.nextBaselineDigest
+              });
+            } catch (error) {
+              try {
+                ctx.ui.notify(`Piagent expanded legacy task evidence coverage, but its auxiliary trace could not be written: ${error instanceof Error ? error.message : String(error)}`, "warning");
+              } catch {
+                // UI availability is not part of the durable coverage commit.
+              }
+            }
+          } catch (error) {
+            try {
+              ctx.ui.notify(`Piagent kept the existing task baseline because its evidence-coverage refresh could not be persisted: ${error instanceof Error ? error.message : String(error)}`, "warning");
+            } catch {
+              // Continue startup with the last durably readable task.
+            }
+            refreshTask = dependencies.activeTask(ctx.cwd, sessionId) ?? latestTask;
+            resumedTask = refreshTask;
+          }
+        }
+        const refreshResume = dependencies.inspectResume(ctx.cwd, refreshTask, sessionId);
+        const refreshAllowed = refreshResume.enforcementSafe
+          && refreshResume.decision !== "blocked"
+          && refreshResume.decision !== "paused";
+        if (refreshAllowed) {
+          const refresh = refreshPristineRuntimeTaskVerification(ctx.cwd, refreshTask, profile);
+          if (refresh.refreshed) {
+            try {
+              resumedTask = dependencies.writeTask(ctx.cwd, refresh.task);
+              try {
+                dependencies.appendTrace(ctx.cwd, {
+                  event: "task_pristine_verifier_refreshed",
+                  taskId: resumedTask.taskId,
+                  taskRunId: resumedTask.taskRunId,
+                  sessionId,
+                  sessionName,
+                  reason: refresh.reason,
+                  verifyGroup: refresh.verifyGroup,
+                  previousCommands: refresh.previousCommands,
+                  verifyCommands: refresh.nextCommands
+                });
+              } catch (error) {
+                // The contract write and its task journal entry are already
+                // durable. An auxiliary trace/notice failure must not abort
+                // session startup or roll the task back to stale commands.
+                try {
+                  ctx.ui.notify(`Piagent refreshed the task verifier, but its auxiliary trace could not be written: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                } catch {
+                  // UI availability is not part of the durable refresh commit.
+                }
+              }
+            } catch (error) {
+              try {
+                ctx.ui.notify(`Piagent kept the existing task verifier because its pristine refresh could not be persisted: ${error instanceof Error ? error.message : String(error)}`, "warning");
+              } catch {
+                // Continue startup with the last durably readable task.
+              }
+              resumedTask = dependencies.activeTask(ctx.cwd, sessionId) ?? refreshTask;
+            }
+          }
+        }
+      }
+    }
     if (resumedTask?.workingTreeDigestMigration && resumedTask.workingTreeDigestMigration.status !== "refreshed") dependencies.state.clearDigestMigrationState(ctx, resumedTask.taskRunId, resumedTask.taskId);
-    dependencies.state.cacheTaskIdentity(ctx, resumedTask);
-    const resumeState = resumedTask ? dependencies.inspectResume(ctx.cwd, resumedTask, sessionId) : undefined;
+    if (resumedTask?.trace.outcome === "pending") dependencies.state.cacheTaskIdentity(ctx, resumedTask);
+    else dependencies.state.clearSession(ctx);
+    const resumeState = resumedTask?.trace.outcome === "pending" ? dependencies.inspectResume(ctx.cwd, resumedTask, sessionId) : undefined;
     if (resumeState) dependencies.state.rememberResumeState(resumeState);
     if (resumedTask && resumeState?.enforcementSafe) observeTrajectorySync(ctx, dependencies.syncTrajectory?.(ctx, resumedTask), dependencies.telemetry);
     let taskRecovery: Record<string, unknown> | undefined;
@@ -179,7 +280,6 @@ export function registerSessionStartHook(pi: ExtensionAPI, dependencies: Session
       : " (run /onboard to select a profile)";
     const snapshot = buildUsageSnapshot(ctx, String(pi.getThinkingLevel()));
     const preflight = buildContextPreflight(snapshot, "task", 0);
-    const capabilityState = dependencies.capabilityState(ctx);
     const permissionProfile = dependencies.permissionProfile(ctx, profile);
     const executionBackend = resolveExecutionBackend();
     const contextHint = preflight.recommendation === "fresh-session"
@@ -217,6 +317,10 @@ export function registerSessionStartHook(pi: ExtensionAPI, dependencies: Session
     }
     dependencies.telemetry(ctx, {
       event: "session_start",
+      // Benchmark and efficiency projections must be able to distinguish a
+      // genuine zero-recovery session from telemetry produced before this
+      // receipt/result protocol existed.
+      editRecoveryContextTelemetryVersion: 1,
       activeTools: pi.getActiveTools().length,
       index: engineStatus,
       taskMigration: migration,

package/packages/piagent-core/runtime/hooks/tool-result-content-guards.ts

@@ -0,0 +1,95 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { matchesProtectedPath } from "../../extensions/policy-core.js";
+
+function normalizeRelative(cwd: string, candidate: unknown): string | undefined {
+  if (typeof candidate !== "string" || candidate.trim().length === 0) return undefined;
+  let raw = candidate.trim();
+  try {
+    raw = decodeURIComponent(raw);
+  } catch {
+    return undefined;
+  }
+  if (/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(raw)) {
+    if (!raw.toLowerCase().startsWith("file://")) return undefined;
+    try {
+      raw = fileURLToPath(raw);
+    } catch {
+      return undefined;
+    }
+  }
+  const absolute = path.isAbsolute(raw) ? raw : path.resolve(cwd, raw);
+  return path.relative(cwd, absolute).split(path.sep).join("/");
+}
+
+function filterTextBlocks(
+  content: unknown,
+  blocked: (line: string) => boolean,
+  emptyText: string,
+  noticeText: (count: number) => string
+): { changed: boolean; content?: unknown; redactedLines: number } {
+  if (!Array.isArray(content)) return { changed: false, redactedLines: 0 };
+  let changed = false;
+  let redactedLines = 0;
+  const filtered = content.map((block) => {
+    if (!block || typeof block !== "object") return block;
+    const text = (block as { type?: unknown; text?: unknown }).text;
+    if ((block as { type?: unknown }).type !== "text" || typeof text !== "string") return block;
+    const kept: string[] = [];
+    let blockRedactedLines = 0;
+    for (const line of text.split(/\r?\n/)) {
+      if (blocked(line)) {
+        changed = true;
+        redactedLines += 1;
+        blockRedactedLines += 1;
+      } else {
+        kept.push(line);
+      }
+    }
+    if (blockRedactedLines === 0) return block;
+    const notice = noticeText(blockRedactedLines);
+    const nextText = kept.join("\n").trim().length > 0
+      ? `${kept.join("\n")}\n${notice}`
+      : `${emptyText}\n${notice}`;
+    return { ...block, text: nextText };
+  });
+  return { changed, content: filtered, redactedLines };
+}
+
+export function filterGrepProtectedContent(content: unknown, protectedPatterns: string[]) {
+  return filterTextBlocks(
+    content,
+    (line) => {
+      const linePath = line.match(/^(.+?)(?::\d+:|-\d+-)/)?.[1];
+      return Boolean(linePath && matchesProtectedPath(linePath, protectedPatterns));
+    },
+    "No matches found in non-protected paths.",
+    (count) => `[Piagent Pi guard redacted ${count} protected grep line${count === 1 ? "" : "s"}.]`
+  );
+}
+
+export function filterProtectedPathListContent(
+  cwd: string,
+  content: unknown,
+  protectedPatterns: string[],
+  basePath: string,
+  toolName: string
+) {
+  return filterTextBlocks(
+    content,
+    (line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("[") || trimmed.startsWith("No ") || trimmed === "(empty directory)") return false;
+      const entry = trimmed.replace(/[\\/]+$/, "");
+      const candidates = new Set<string>();
+      const direct = normalizeRelative(cwd, entry);
+      const underBase = normalizeRelative(cwd, path.posix.join(basePath || ".", entry));
+      if (direct !== undefined) candidates.add(direct);
+      if (underBase !== undefined) candidates.add(underBase);
+      return [...candidates].some((candidate) => matchesProtectedPath(candidate, protectedPatterns));
+    },
+    "No entries found in non-protected paths.",
+    (count) => `[Piagent Pi guard redacted ${count} protected ${toolName} line${count === 1 ? "" : "s"}.]`
+  );
+}