gsd-pi 2.28.0 → 2.29.0-dev.23d50d0

package/dist/resources/extensions/gsd/tests/auto-session-encapsulation.test.ts

@@ -0,0 +1,257 @@
+/**
+ * auto-session-encapsulation.test.ts — Guards the AutoSession encapsulation invariant.
+ *
+ * All mutable auto-mode state must live in AutoSession (auto/session.ts).
+ * auto.ts must not declare module-level `let` or `var` variables.
+ *
+ * These tests parse auto.ts source to detect violations, so they fail at
+ * test time — before a PR merges — when someone accidentally adds mutable
+ * module-level state to auto.ts instead of AutoSession.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
+const SESSION_TS_PATH = join(__dirname, "..", "auto", "session.ts");
+
+function getAutoTsSource(): string {
+  return readFileSync(AUTO_TS_PATH, "utf-8");
+}
+
+function getSessionTsSource(): string {
+  return readFileSync(SESSION_TS_PATH, "utf-8");
+}
+
+// ── Invariant 1: No module-level mutable variables in auto.ts ────────────────
+
+test("auto.ts has no module-level let declarations", () => {
+  const source = getAutoTsSource();
+  const lines = source.split("\n");
+  const violations: string[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    // Match lines starting with `let ` or `export let ` (module-level)
+    // Skip lines inside functions/blocks (indented)
+    if (/^(export\s+)?let\s+/.test(line)) {
+      violations.push(`line ${i + 1}: ${line.trim()}`);
+    }
+  }
+
+  assert.equal(
+    violations.length,
+    0,
+    `auto.ts must not have module-level \`let\` declarations. ` +
+    `All mutable state belongs in AutoSession (auto/session.ts).\n` +
+    `Violations:\n${violations.join("\n")}`,
+  );
+});
+
+test("auto.ts has no module-level var declarations", () => {
+  const source = getAutoTsSource();
+  const lines = source.split("\n");
+  const violations: string[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    if (/^(export\s+)?var\s+/.test(line)) {
+      violations.push(`line ${i + 1}: ${line.trim()}`);
+    }
+  }
+
+  assert.equal(
+    violations.length,
+    0,
+    `auto.ts must not have module-level \`var\` declarations. ` +
+    `All mutable state belongs in AutoSession (auto/session.ts).\n` +
+    `Violations:\n${violations.join("\n")}`,
+  );
+});
+
+// ── Invariant 2: AutoSession singleton is the only mutable module-level binding ──
+
+test("auto.ts has exactly one module-level const for AutoSession", () => {
+  const source = getAutoTsSource();
+  const lines = source.split("\n");
+
+  const sessionConsts = lines.filter(line =>
+    /^const\s+\w+\s*=\s*new\s+AutoSession/.test(line),
+  );
+
+  assert.equal(
+    sessionConsts.length,
+    1,
+    `auto.ts should have exactly one \`const s = new AutoSession()\`. ` +
+    `Found ${sessionConsts.length}: ${sessionConsts.join(", ")}`,
+  );
+});
+
+// ── Invariant 3: AutoSession.reset() covers all instance properties ──────────
+
+test("AutoSession.reset() references every instance property", () => {
+  const source = getSessionTsSource();
+
+  // Extract property names from class body (lines like `  propName = ...` or `  propName:`)
+  // Skip readonly collections (Maps/Sets) that use .clear() instead of reassignment
+  const propertyPattern = /^\s+(readonly\s+)?(\w+)\s*[:=]/;
+  const properties: string[] = [];
+  let inClass = false;
+  let inMethod = false;
+  let braceDepth = 0;
+
+  for (const line of source.split("\n")) {
+    if (/^export class AutoSession/.test(line)) {
+      inClass = true;
+      braceDepth = 0;
+      continue;
+    }
+    if (!inClass) continue;
+
+    // Track brace depth to distinguish properties from method bodies
+    for (const ch of line) {
+      if (ch === "{") braceDepth++;
+      if (ch === "}") braceDepth--;
+    }
+
+    // Class-level properties are at brace depth 1 (inside the class, outside methods)
+    if (braceDepth === 1 && !inMethod) {
+      const match = line.match(propertyPattern);
+      if (match && match[2]) {
+        const propName = match[2];
+        // Skip method-like names and type-only declarations
+        if (!["constructor", "clearTimers", "resetDispatchCounters", "lockBasePath",
+               "completeCurrentUnit", "reset", "toJSON"].includes(propName)) {
+          properties.push(propName);
+        }
+      }
+    }
+
+    // Detect method start/end
+    if (braceDepth === 1 && /^\s+(get |async )?(\w+)\s*\(/.test(line)) {
+      inMethod = true;
+    }
+    if (braceDepth === 1 && inMethod) {
+      inMethod = false;
+    }
+  }
+
+  // Extract the reset() method body
+  const resetMatch = source.match(/reset\(\): void \{([\s\S]*?)^\s{2}\}/m);
+  assert.ok(resetMatch, "AutoSession.reset() method not found");
+  const resetBody = resetMatch![1]!;
+
+  // completedKeySet is intentionally not cleared (documented in reset())
+  const intentionallySkipped = new Set(["completedKeySet"]);
+
+  const missingFromReset: string[] = [];
+  for (const prop of properties) {
+    if (intentionallySkipped.has(prop)) continue;
+    // Check if the property name appears in reset body (as `this.prop` assignment or `.clear()`)
+    if (!resetBody.includes(`this.${prop}`)) {
+      missingFromReset.push(prop);
+    }
+  }
+
+  assert.equal(
+    missingFromReset.length,
+    0,
+    `AutoSession.reset() must reference every instance property. ` +
+    `Missing: ${missingFromReset.join(", ")}. ` +
+    `If a property should persist across resets, add it to the intentionallySkipped set in this test.`,
+  );
+});
+
+// ── Invariant 4: AutoSession.toJSON() provides diagnostic visibility ─────────
+
+test("AutoSession.toJSON() includes key diagnostic properties", () => {
+  const source = getSessionTsSource();
+
+  const toJSONMatch = source.match(/toJSON\(\)[\s\S]*?return \{([\s\S]*?)\};/);
+  assert.ok(toJSONMatch, "AutoSession.toJSON() method not found");
+  const toJSONBody = toJSONMatch![1]!;
+
+  // These are the minimum properties needed for diagnostic snapshots
+  const requiredDiagnostics = [
+    "active",
+    "paused",
+    "basePath",
+    "currentMilestoneId",
+    "currentUnit",
+    "dispatching",
+  ];
+
+  const missing = requiredDiagnostics.filter(prop => !toJSONBody.includes(prop));
+
+  assert.equal(
+    missing.length,
+    0,
+    `AutoSession.toJSON() must include diagnostic properties: ${missing.join(", ")}`,
+  );
+});
+
+// ── Invariant 5: No state-bearing module-level consts that should be in AutoSession ──
+
+test("auto.ts module-level consts are only AutoSession instance, true constants, or static accessors", () => {
+  const source = getAutoTsSource();
+  const lines = source.split("\n");
+  const violations: string[] = [];
+
+  // Patterns that are acceptable at module level
+  const allowedPatterns = [
+    /^const s = new AutoSession/,                 // The session singleton
+    /^const [A-Z_]+\s*=/,                          // UPPER_CASE constants
+    /^const \w+StateAccessors/,                    // Static accessor objects
+    /^const \w+:\s*\w+\s*=/,                       // Typed constants
+  ];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    if (!/^(export\s+)?const\s+/.test(line)) continue;
+
+    const isAllowed = allowedPatterns.some(p => p.test(line.replace(/^export\s+/, "")));
+    if (!isAllowed) {
+      // Check if it looks like mutable state (arrays, objects with mutable semantics)
+      if (/= new (Map|Set|Array)\(/.test(line) || /= \[\]/.test(line)) {
+        violations.push(`line ${i + 1}: ${line.trim()}`);
+      }
+    }
+  }
+
+  assert.equal(
+    violations.length,
+    0,
+    `auto.ts has module-level const declarations that look like mutable state. ` +
+    `Move these into AutoSession:\n${violations.join("\n")}`,
+  );
+});
+
+// ── Invariant 6: session.ts file exists and exports AutoSession ──────────────
+
+test("auto/session.ts exports AutoSession class", () => {
+  const source = getSessionTsSource();
+  assert.ok(
+    /export class AutoSession/.test(source),
+    "auto/session.ts must export the AutoSession class",
+  );
+});
+
+test("AutoSession has a reset() method", () => {
+  const source = getSessionTsSource();
+  assert.ok(
+    /reset\(\): void/.test(source),
+    "AutoSession must have a reset(): void method",
+  );
+});
+
+test("AutoSession has a toJSON() method", () => {
+  const source = getSessionTsSource();
+  assert.ok(
+    /toJSON\(\)/.test(source),
+    "AutoSession must have a toJSON() method for diagnostics",
+  );
+});

package/dist/resources/extensions/gsd/tests/auto-skip-loop.test.ts

@@ -17,8 +17,8 @@ import { tmpdir } from "node:os";
 import {
   _getUnitConsecutiveSkips,
   _resetUnitConsecutiveSkips,
-  MAX_CONSECUTIVE_SKIPS,
 } from "../auto.ts";
+import { MAX_CONSECUTIVE_SKIPS } from "../auto/session.ts";
 import { persistCompletedKey, removePersistedKey, loadPersistedKeys } from "../auto-recovery.ts";
 import { createTestContext } from "./test-helpers.ts";
 

package/dist/resources/extensions/gsd/tests/auto-worktree-milestone-merge.test.ts

@@ -32,6 +32,9 @@ function createTempRepo(): string {
   run("git config user.email test@test.com", dir);
   run("git config user.name Test", dir);
   writeFileSync(join(dir, "README.md"), "# test\n");
+  // Mirror production: GSD runtime dirs are gitignored so autoCommitDirtyState
+  // doesn't pick up the worktrees directory as dirty state (#1127 fix).
+  writeFileSync(join(dir, ".gitignore"), ".gsd/worktrees/\n");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
   writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
   run("git add .", dir);

package/dist/resources/extensions/gsd/tests/commands-logs.test.ts

@@ -0,0 +1,241 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync, rmSync, existsSync, utimesSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { handleLogs } from "../commands-logs.ts";
+
+// ─── Test helpers ───────────────────────────────────────────────────────────
+
+function createTestDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-logs-test-"));
+  mkdirSync(join(dir, ".gsd", "activity"), { recursive: true });
+  mkdirSync(join(dir, ".gsd", "debug"), { recursive: true });
+  return dir;
+}
+
+function createMockCtx(): { notifications: Array<{ msg: string; level: string }>; ui: any } {
+  const notifications: Array<{ msg: string; level: string }> = [];
+  return {
+    notifications,
+    ui: {
+      notify(msg: string, level: string) { notifications.push({ msg, level }); },
+      setStatus() {},
+      setWidget() {},
+      setFooter() {},
+    },
+  };
+}
+
+function writeActivityLog(dir: string, seq: number, unitType: string, unitId: string, entries: Record<string, unknown>[]): void {
+  const safeId = unitId.replace(/\//g, "-");
+  const filename = `${String(seq).padStart(3, "0")}-${unitType}-${safeId}.jsonl`;
+  const content = entries.map(e => JSON.stringify(e)).join("\n") + "\n";
+  writeFileSync(join(dir, ".gsd", "activity", filename), content);
+}
+
+function writeDebugLog(dir: string, name: string, entries: Record<string, unknown>[]): void {
+  const content = entries.map(e => JSON.stringify(e)).join("\n") + "\n";
+  writeFileSync(join(dir, ".gsd", "debug", name), content);
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+test("logs shows empty state message when no logs exist", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+  try {
+    await handleLogs("", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    assert.ok(ctx.notifications[0].msg.includes("No logs found"));
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs lists activity logs", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [
+    { type: "toolCall", name: "bash", arguments: { command: "npm test" } },
+    { role: "toolResult", toolCallId: "1", toolName: "bash", isError: false },
+  ]);
+  writeActivityLog(dir, 2, "complete-slice", "M001/S01", [
+    { role: "assistant", content: "Completing slice S01" },
+  ]);
+
+  try {
+    await handleLogs("", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Activity Logs"), "should show activity logs header");
+    assert.ok(msg.includes("execute-task"), "should show unit type");
+    assert.ok(msg.includes("complete-slice"), "should show second log");
+    assert.ok(msg.includes("/gsd logs <#>"), "should show usage hint");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs <N> shows activity log details", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [
+    { type: "toolCall", name: "bash", arguments: { command: "npm test" } },
+    { type: "toolCall", name: "write", arguments: { file_path: "/tmp/test.ts" } },
+    { role: "toolResult", toolCallId: "1", toolName: "bash", isError: false },
+    { role: "toolResult", toolCallId: "2", toolName: "write", isError: true },
+    { role: "assistant", content: "I ran the tests and wrote a file" },
+  ]);
+
+  try {
+    await handleLogs("1", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Activity Log #1"), "should show log number");
+    assert.ok(msg.includes("execute-task"), "should show unit type");
+    assert.ok(msg.includes("Tool calls: 2"), "should count tool calls");
+    assert.ok(msg.includes("Errors: 1"), "should count errors");
+    assert.ok(msg.includes("/tmp/test.ts"), "should show files written");
+    assert.ok(msg.includes("npm test"), "should show commands run");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs <N> shows not found for invalid seq", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  try {
+    await handleLogs("999", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    assert.ok(ctx.notifications[0].msg.includes("not found"));
+    assert.equal(ctx.notifications[0].level, "warning");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs debug lists debug logs", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  writeDebugLog(dir, "debug-2026-03-18T10-30-00.log", [
+    { ts: "2026-03-18T10:30:00Z", event: "debug-start", platform: "darwin" },
+    { ts: "2026-03-18T10:35:00Z", event: "debug-summary", dispatches: 5 },
+  ]);
+
+  try {
+    await handleLogs("debug", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Debug Logs"), "should show debug logs header");
+    assert.ok(msg.includes("debug-2026-03-18T10-30-00.log"), "should show filename");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs debug <N> shows debug log summary", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  writeDebugLog(dir, "debug-2026-03-18T10-30-00.log", [
+    { ts: "2026-03-18T10:30:00Z", event: "debug-start", platform: "darwin" },
+    { ts: "2026-03-18T10:30:05Z", event: "dispatch-error", error: "missing plan" },
+    { ts: "2026-03-18T10:35:00Z", event: "debug-summary", dispatches: 5 },
+  ]);
+
+  try {
+    await handleLogs("debug 1", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Debug Log:"), "should show debug log header");
+    assert.ok(msg.includes("Events: 3"), "should count events");
+    assert.ok(msg.includes("Dispatches: 5"), "should show dispatch count");
+    assert.ok(msg.includes("dispatch-error"), "should show errors");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs tail shows recent activity summaries", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [
+    { type: "toolCall", name: "bash", arguments: { command: "npm test" } },
+  ]);
+  writeActivityLog(dir, 2, "execute-task", "M001/S01/T02", [
+    { type: "toolCall", name: "bash", arguments: { command: "npm build" } },
+    { role: "toolResult", toolCallId: "1", toolName: "bash", isError: true },
+  ]);
+
+  try {
+    await handleLogs("tail 2", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Last 2 activity log(s)"), "should show count");
+    assert.ok(msg.includes("#1"), "should show first log");
+    assert.ok(msg.includes("#2"), "should show second log");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs clear removes old logs", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  // Create an old activity log (modify mtime to 10 days ago)
+  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [{ type: "toolCall" }]);
+  const oldFile = join(dir, ".gsd", "activity", "001-execute-task-M001-S01-T01.jsonl");
+  const oldTime = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000);
+  utimesSync(oldFile, oldTime, oldTime);
+
+  // Create 6 recent activity logs so the old one is outside the "keep 5" window
+  for (let i = 2; i <= 7; i++) {
+    writeActivityLog(dir, i, "execute-task", `M001/S01/T0${i}`, [{ type: "toolCall" }]);
+  }
+
+  try {
+    await handleLogs("clear", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    // Old log should be removed, recent ones kept
+    assert.ok(!existsSync(oldFile), "old log should be removed");
+    assert.ok(
+      existsSync(join(dir, ".gsd", "activity", "007-execute-task-M001-S01-T07.jsonl")),
+      "most recent log should be kept",
+    );
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/dist/resources/extensions/gsd/tests/context-budget.test.ts

@@ -18,6 +18,8 @@ import {
   resolveExecutorContextWindow,
 } from "../context-budget.js";
 
+import type { TokenProvider } from "../token-counter.js";
+
 // ─── Test helpers ─────────────────────────────────────────────────────────────
 
 function makeRegistry(models: MinimalModel[]): MinimalModelRegistry {
@@ -281,3 +283,70 @@ describe("context-budget: resolveExecutorContextWindow", () => {
     assert.equal(result, 200_000); // falls through to default
   });
 });
+
+// ─── computeBudgets with provider ─────────────────────────────────────────────
+
+describe("context-budget: computeBudgets with provider", () => {
+  it("anthropic budgets differ from default budgets for same window", () => {
+    const defaultBudgets = computeBudgets(200_000);
+    const anthropicBudgets = computeBudgets(200_000, "anthropic");
+
+    // anthropic uses 3.5 chars/token vs default 4.0
+    // so anthropic totalChars = 200K * 3.5 = 700K vs default 200K * 4 = 800K
+    assert.ok(
+      anthropicBudgets.summaryBudgetChars < defaultBudgets.summaryBudgetChars,
+      `anthropic summary (${anthropicBudgets.summaryBudgetChars}) should be less than default (${defaultBudgets.summaryBudgetChars})`,
+    );
+    assert.ok(
+      anthropicBudgets.inlineContextBudgetChars < defaultBudgets.inlineContextBudgetChars,
+      `anthropic inline (${anthropicBudgets.inlineContextBudgetChars}) should be less than default (${defaultBudgets.inlineContextBudgetChars})`,
+    );
+  });
+
+  it("openai provider matches default budgets (both use 4.0 chars/token)", () => {
+    const defaultBudgets = computeBudgets(128_000);
+    const openaiBudgets = computeBudgets(128_000, "openai");
+
+    assert.deepStrictEqual(openaiBudgets, defaultBudgets);
+  });
+
+  it("anthropic budgets are proportional to 3.5 chars/token", () => {
+    const b = computeBudgets(200_000, "anthropic");
+    // 200K tokens * 3.5 chars/token = 700K chars total
+    assert.equal(b.summaryBudgetChars, Math.floor(700_000 * 0.15));
+    assert.equal(b.inlineContextBudgetChars, Math.floor(700_000 * 0.40));
+    assert.equal(b.verificationBudgetChars, Math.floor(700_000 * 0.10));
+  });
+
+  it("bedrock budgets match anthropic (both use 3.5 chars/token)", () => {
+    const anthropicBudgets = computeBudgets(200_000, "anthropic");
+    const bedrockBudgets = computeBudgets(200_000, "bedrock");
+
+    assert.deepStrictEqual(bedrockBudgets, anthropicBudgets);
+  });
+
+  it("default behavior unchanged when no provider is passed", () => {
+    const b = computeBudgets(128_000);
+    // 128K * 4 = 512K
+    assert.equal(b.summaryBudgetChars, Math.floor(512_000 * 0.15));
+    assert.equal(b.inlineContextBudgetChars, Math.floor(512_000 * 0.40));
+    assert.equal(b.verificationBudgetChars, Math.floor(512_000 * 0.10));
+    assert.equal(b.continueThresholdPercent, 70);
+    assert.equal(b.taskCountRange.min, 2);
+    assert.equal(b.taskCountRange.max, 5);
+  });
+
+  it("task count range is unaffected by provider", () => {
+    const defaultBudgets = computeBudgets(200_000);
+    const anthropicBudgets = computeBudgets(200_000, "anthropic");
+
+    assert.deepStrictEqual(anthropicBudgets.taskCountRange, defaultBudgets.taskCountRange);
+    assert.equal(anthropicBudgets.continueThresholdPercent, defaultBudgets.continueThresholdPercent);
+  });
+
+  it("handles zero input with provider — defaults to 200K", () => {
+    const b = computeBudgets(0, "anthropic");
+    const b200 = computeBudgets(200_000, "anthropic");
+    assert.deepStrictEqual(b, b200);
+  });
+});