astrocode-workflow 0.0.1

package/src/tools/story.ts

@@ -0,0 +1,106 @@
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import { withTx } from "../state/db";
+import { nowISO } from "../shared/time";
+import type { StoryState } from "../state/types";
+
+import { insertStory } from "../workflow/story-helpers";
+
+
+export function createAstroStoryQueueTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { db } = opts;
+
+  return tool({
+    description: "Create a queued story (ticket) in Astrocode. Returns story_key.",
+    args: {
+      title: tool.schema.string().min(1),
+      body_md: tool.schema.string().default(""),
+      epic_key: tool.schema.string().optional(),
+      priority: tool.schema.number().int().default(0),
+    },
+    execute: async ({ title, body_md, epic_key, priority }) => {
+      const now = nowISO();
+      const story_key = withTx(db, () => {
+        return insertStory(db, { title, body_md, epic_key: epic_key ?? null, priority: priority ?? 0, state: 'queued' });
+      });
+
+      return `✅ Queued story ${story_key}: ${title}`;
+    },
+  });
+}
+
+export function createAstroStoryApproveTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { db } = opts;
+
+  return tool({
+    description: "Approve a story so it becomes eligible to run.",
+    args: {
+      story_key: tool.schema.string().min(1),
+    },
+    execute: async ({ story_key }) => {
+      const now = nowISO();
+      const row = db.prepare("SELECT story_key, state, title FROM stories WHERE story_key=?").get(story_key) as any;
+      if (!row) throw new Error(`Story not found: ${story_key}`);
+
+      if (row.state === "approved") return `ℹ️ Story ${story_key} already approved.`;
+
+      db.prepare("UPDATE stories SET state='approved', approved_at=?, updated_at=? WHERE story_key=?").run(now, now, story_key);
+      return `✅ Approved story ${story_key}: ${row.title}`;
+    },
+  });
+}
+
+export function createAstroStoryBoardTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { db } = opts;
+
+  return tool({
+    description: "Show stories grouped by state (a compact board).",
+    args: {
+      limit_per_state: tool.schema.number().int().positive().default(20),
+    },
+    execute: async ({ limit_per_state }) => {
+      const states: StoryState[] = ["queued", "approved", "in_progress", "blocked", "done", "archived"];
+      const lines: string[] = [];
+      lines.push("# Story board");
+
+      for (const st of states) {
+        const rows = db
+          .prepare(
+            "SELECT story_key, title, priority, created_at FROM stories WHERE state=? ORDER BY priority DESC, created_at ASC LIMIT ?"
+          )
+          .all(st, limit_per_state) as Array<any>;
+        lines.push("", `## ${st} (${rows.length})`);
+        for (const r of rows) lines.push(`- \`${r.story_key}\` (p=${r.priority}) — ${r.title}`);
+      }
+
+      return lines.join("\n").trim();
+    },
+  });
+}
+
+export function createAstroStorySetStateTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { db } = opts;
+
+  return tool({
+    description:
+      "Admin: set story state manually (queued|approved|in_progress|done|blocked|archived). Use carefully.",
+    args: {
+      story_key: tool.schema.string().min(1),
+      state: tool.schema.enum(["queued", "approved", "in_progress", "done", "blocked", "archived"]),
+      note: tool.schema.string().default(""),
+    },
+    execute: async ({ story_key, state, note }) => {
+      const now = nowISO();
+      const row = db.prepare("SELECT story_key, title, state FROM stories WHERE story_key=?").get(story_key) as any;
+      if (!row) throw new Error(`Story not found: ${story_key}`);
+
+      db.prepare("UPDATE stories SET state=?, updated_at=? WHERE story_key=?").run(state, now, story_key);
+      db.prepare(
+        "INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, 'story.state_set', ?, ?)"
+      ).run(`evt_${Date.now()}_${Math.random().toString(16).slice(2)}`, JSON.stringify({ story_key, from: row.state, to: state, note }), now);
+
+      return `✅ Story ${story_key} state: ${row.state} → ${state}${note ? ` (${note})` : ""}`;
+    },
+  });
+}

package/src/tools/workflow.ts

@@ -0,0 +1,241 @@
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import { withTx } from "../state/db";
+import type { StageKey } from "../state/types";
+import { buildContextSnapshot } from "../workflow/context";
+import { decideNextAction, createRunForStory, startStage, completeRun, getActiveRun } from "../workflow/state-machine";
+import { buildStageDirective, directiveHash } from "../workflow/directives";
+import { injectChatPrompt } from "../ui/inject";
+import { nowISO } from "../shared/time";
+import { newEventId } from "../state/ids";
+import { createToastManager } from "../ui/toasts";
+
+function stageGoal(stage: StageKey, cfg: AstrocodeConfig): string {
+  switch (stage) {
+    case "frame":
+      return "Define scope, constraints, and an unambiguous Definition of Done.";
+    case "plan":
+      return `Produce a bounded task plan (<= ${cfg.workflow.plan_max_tasks} tasks) tied to files and tests.`;
+    case "spec":
+      return "Produce minimal spec/contract: interfaces, invariants, acceptance checks.";
+    case "implement":
+      return "Implement the spec with minimal changes, referencing diffs and evidence as artifacts.";
+    case "review":
+      return "Review implementation for correctness, risks, and alignment with spec.";
+    case "verify":
+      return "Run verification commands and produce evidence artifacts.";
+    case "close":
+      return "Summarize outcome and confirm acceptance criteria, leaving clear breadcrumbs.";
+  }
+}
+
+function stageConstraints(stage: StageKey, cfg: AstrocodeConfig): string[] {
+  const common = [
+    "Do not narrate prompts.",
+    "Keep baton markdown short and structured.",
+    "If blocked: ask exactly ONE question and stop.",
+  ];
+
+  if (stage === "plan") {
+    common.push(`Hard limit: <= ${cfg.workflow.plan_max_tasks} tasks and <= ${cfg.workflow.plan_max_lines} lines of plan output.`);
+  }
+  if (stage === "verify" && cfg.workflow.evidence_required.verify) {
+    common.push("Evidence required: ASTRO JSON must include evidence[] paths.");
+  }
+  return common;
+}
+
+function agentNameForStage(stage: StageKey, cfg: AstrocodeConfig): string {
+  return cfg.agents.stage_agent_names[stage];
+}
+
+function buildDelegationPrompt(opts: {
+  stageDirective: string;
+  run_id: string;
+  stage_key: StageKey;
+  stage_agent_name: string;
+}): string {
+  const { stageDirective, run_id, stage_key, stage_agent_name } = opts;
+  const stageUpper = stage_key.toUpperCase();
+
+  return [
+    `[SYSTEM DIRECTIVE: ASTROCODE — DELEGATE_STAGE_${stageUpper}]`,
+    ``,
+    `Do this now, in order:`,
+    `1) Call the **task** tool to delegate to subagent \`${stage_agent_name}\`.`,
+    `   - Pass this exact prompt text to the subagent (copy/paste):`,
+    ``,
+    stageDirective,
+    ``,
+    `2) When the subagent returns, immediately call **astro_stage_complete** with:`,
+    `   - run_id = "${run_id}"`,
+    `   - stage_key = "${stage_key}"`,
+    `   - output_text = (the FULL subagent response text)`,
+    ``,
+    `3) Then call **astro_workflow_proceed** again (mode=step).`,
+    ``,
+    `Important: do NOT do any stage work yourself in orchestrator mode.`,
+  ].join("\n").trim();
+}
+
+export function createAstroWorkflowProceedTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { ctx, config, db } = opts;
+  const toasts = createToastManager({ ctx, throttleMs: config.ui.toasts.throttle_ms });
+
+  return tool({
+    description:
+      "Deterministic harness: advances the DB-driven pipeline by one step (or loops bounded). Stops when LLM work is required (delegation/await).",
+    args: {
+      mode: tool.schema.enum(["step", "loop"]).default(config.workflow.default_mode),
+      max_steps: tool.schema.number().int().positive().default(config.workflow.default_max_steps),
+    },
+    execute: async ({ mode, max_steps }) => {
+      const sessionId = (ctx as any).sessionID as string | undefined;
+      const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
+
+      const actions: string[] = [];
+      const startedAt = nowISO();
+
+      for (let i = 0; i < steps; i++) {
+        const next = decideNextAction(db, config);
+
+        if (next.kind === "idle") {
+          actions.push("idle: no approved stories");
+          break;
+        }
+
+        if (next.kind === "start_run") {
+          const { run_id } = withTx(db, () => createRunForStory(db, config, next.story_key));
+          actions.push(`started run ${run_id} for story ${next.story_key}`);
+
+          if (config.ui.toasts.enabled && config.ui.toasts.show_run_started) {
+            await toasts.show({ title: "Astrocode", message: `Run started (${run_id})`, variant: "success" });
+          }
+
+          if (mode === "step") break;
+          continue;
+        }
+
+        if (next.kind === "complete_run") {
+          withTx(db, () => completeRun(db, next.run_id));
+          actions.push(`completed run ${next.run_id}`);
+
+          if (config.ui.toasts.enabled && config.ui.toasts.show_run_completed) {
+            await toasts.show({ title: "Astrocode", message: `Run completed (${next.run_id})`, variant: "success" });
+          }
+
+          if (mode === "step") break;
+          continue;
+        }
+
+        if (next.kind === "delegate_stage") {
+          const active = getActiveRun(db);
+          if (!active) throw new Error("Invariant: delegate_stage but no active run.");
+          const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(active.run_id) as any;
+          const story = db.prepare("SELECT * FROM stories WHERE story_key=?").get(run.story_key) as any;
+
+          // Mark stage started + set subagent_type to the stage agent.
+          const agentName = agentNameForStage(next.stage_key, config);
+          withTx(db, () => {
+            startStage(db, active.run_id, next.stage_key, { subagent_type: agentName });
+          });
+
+          if (config.ui.toasts.enabled && config.ui.toasts.show_stage_started) {
+            await toasts.show({ title: "Astrocode", message: `Stage started: ${next.stage_key}`, variant: "info" });
+          }
+
+          const context = buildContextSnapshot({ db, config, run_id: active.run_id, next_action: `delegate stage ${next.stage_key}` });
+
+          const stageDirective = buildStageDirective({
+            config,
+            stage_key: next.stage_key,
+            run_id: active.run_id,
+            story_key: run.story_key,
+            story_title: story?.title ?? "(missing)",
+            stage_agent_name: agentName,
+            stage_goal: stageGoal(next.stage_key, config),
+            stage_constraints: stageConstraints(next.stage_key, config),
+            context_snapshot_md: context,
+          }).body;
+
+          const delegatePrompt = buildDelegationPrompt({
+            stageDirective,
+            run_id: active.run_id,
+            stage_key: next.stage_key,
+            stage_agent_name: agentName,
+          });
+
+          // Record in continuations as a stage directive (dedupe by hash)
+          const h = directiveHash(delegatePrompt);
+          const now = nowISO();
+          if (sessionId) {
+            db.prepare(
+              "INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'stage', ?, ?)"
+            ).run(sessionId, active.run_id, h, `delegate ${next.stage_key}`, now);
+          }
+
+          // Visible injection so user can see state
+          if (sessionId) {
+            await injectChatPrompt({ ctx, sessionId, text: delegatePrompt });
+          }
+
+          actions.push(`delegated stage ${next.stage_key} via ${agentName}`);
+
+          // Stop here; subagent needs to run.
+          break;
+        }
+
+        if (next.kind === "await_stage_completion") {
+          actions.push(`await stage completion: ${next.stage_key}`);
+          // Optionally nudge with a short directive
+          if (sessionId) {
+            const context = buildContextSnapshot({ db, config, run_id: next.run_id, next_action: `complete stage ${next.stage_key}` });
+            const prompt = [
+              `[SYSTEM DIRECTIVE: ASTROCODE — AWAIT_STAGE_OUTPUT]`,
+              ``,
+              `Run ${next.run_id} is waiting for stage ${next.stage_key} output.`,
+              `If you have the subagent output, call astro_stage_complete with output_text=the FULL output.`,
+              ``,
+              `Context snapshot:`,
+              context,
+            ].join("\n").trim();
+            const h = directiveHash(prompt);
+            const now = nowISO();
+            db.prepare(
+              "INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'continue', ?, ?)"
+            ).run(sessionId, next.run_id, h, `await ${next.stage_key}`, now);
+
+            await injectChatPrompt({ ctx, sessionId, text: prompt });
+          }
+          break;
+        }
+
+        if (next.kind === "failed") {
+          actions.push(`failed: ${next.stage_key} — ${next.error_text}`);
+          break;
+        }
+
+        // safety
+        actions.push(`unhandled next action: ${(next as any).kind}`);
+        break;
+      }
+
+      // Housekeeping event
+      db.prepare(
+        "INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, 'workflow.proceed', ?, ?)"
+      ).run(newEventId(), JSON.stringify({ started_at: startedAt, mode, max_steps: steps, actions }), nowISO());
+
+      const active = getActiveRun(db);
+      const lines: string[] = [];
+      lines.push(`# astro_workflow_proceed`);
+      lines.push(`- mode: ${mode}`);
+      lines.push(`- steps requested: ${max_steps} (cap=${steps})`);
+      if (active) lines.push(`- active run: \`${active.run_id}\` (stage=${active.current_stage_key ?? "?"})`);
+      lines.push(``, `## Actions`);
+      for (const a of actions) lines.push(`- ${a}`);
+
+      return lines.join("\n").trim();
+    },
+  });
+}

package/src/ui/inject.ts

@@ -0,0 +1,13 @@
+export async function injectChatPrompt(opts: {
+  ctx: any;
+  sessionId: string;
+  text: string;
+}) {
+  const { ctx, sessionId, text } = opts;
+  await ctx.client.session.prompt({
+    path: { id: sessionId },
+    body: {
+      parts: [{ type: "text", text }],
+    },
+  });
+}

package/src/ui/toasts.ts

@@ -0,0 +1,48 @@
+export type ToastVariant = "info" | "success" | "warning" | "error";
+
+export type ToastOptions = {
+  title: string;
+  message: string;
+  variant?: ToastVariant;
+  durationMs?: number;
+};
+
+export function createToastManager(opts: { ctx: any; throttleMs: number }) {
+  const { ctx, throttleMs } = opts;
+  let lastAt = 0;
+
+  async function show(toast: ToastOptions): Promise<void> {
+    const now = Date.now();
+    if (now - lastAt < throttleMs) return;
+    lastAt = now;
+
+    const tui = (ctx as any)?.client?.tui;
+    if (tui?.showToast) {
+      try {
+        await tui.showToast({
+          title: toast.title,
+          message: toast.message,
+          variant: toast.variant ?? "info",
+          durationMs: toast.durationMs ?? 2500,
+        });
+        return;
+      } catch {
+        // fall through
+      }
+    }
+
+    // Fallback: visible chat prompt
+    try {
+      const sessionId = (ctx as any)?.sessionID;
+      if (!sessionId) return;
+      await (ctx as any).client.session.prompt({
+        path: { id: sessionId },
+        body: { parts: [{ type: "text", text: `[ASTRO TOAST] ${toast.title}: ${toast.message}` }] },
+      });
+    } catch {
+      // ignore
+    }
+  }
+
+  return { show };
+}

package/src/workflow/artifacts.ts

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { SqliteDb } from "../state/db";
+import { newArtifactId } from "../state/ids";
+import { nowISO } from "../shared/time";
+import { sha256Hex } from "../shared/hash";
+import { assertInsideAstro, ensureDir, toPosix } from "../shared/paths";
+
+export type ArtifactType =
+  | "baton"
+  | "summary"
+  | "evidence"
+  | "diff"
+  | "log"
+  | "commit"
+  | "tool_output"
+  | "snapshot"
+  | "spec";
+
+export type PutArtifactOpts = {
+  repoRoot: string;
+  db: SqliteDb;
+  run_id?: string | null;
+  stage_key?: string | null;
+  type: ArtifactType | string;
+  rel_path: string; // relative to repo root
+  content: string | Buffer;
+  meta?: Record<string, unknown>;
+};
+
+export function writeFileSafe(repoRoot: string, relPath: string, content: string | Buffer) {
+  const abs = path.join(repoRoot, relPath);
+  assertInsideAstro(repoRoot, abs);
+  ensureDir(path.dirname(abs));
+  fs.writeFileSync(abs, content);
+}
+
+export function putArtifact(opts: PutArtifactOpts): { artifact_id: string; sha256: string; abs_path: string } {
+  const { repoRoot, db, run_id = null, stage_key = null, type, rel_path, content } = opts;
+
+  const artifact_id = newArtifactId();
+  const abs_path = path.join(repoRoot, rel_path);
+  writeFileSafe(repoRoot, rel_path, content);
+
+  const sha256 = sha256Hex(content instanceof Buffer ? content : Buffer.from(content, "utf-8"));
+
+  const created_at = nowISO();
+  const meta_json = JSON.stringify(opts.meta ?? {});
+  db.prepare(
+    "INSERT INTO artifacts (artifact_id, run_id, stage_key, type, path, sha256, meta_json, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+  ).run(artifact_id, run_id, stage_key, type, toPosix(rel_path), sha256, meta_json, created_at);
+
+  return { artifact_id, sha256, abs_path };
+}
+
+export function listArtifacts(db: SqliteDb, filters?: { run_id?: string; stage_key?: string; type?: string }): any[] {
+  const where: string[] = [];
+  const params: any[] = [];
+  if (filters?.run_id) { where.push("run_id = ?"); params.push(filters.run_id); }
+  if (filters?.stage_key) { where.push("stage_key = ?"); params.push(filters.stage_key); }
+  if (filters?.type) { where.push("type = ?"); params.push(filters.type); }
+  const sql = `SELECT * FROM artifacts ${where.length ? "WHERE " + where.join(" AND ") : ""} ORDER BY created_at DESC LIMIT 200`;
+  return db.prepare(sql).all(...params);
+}
+
+export function getArtifact(db: SqliteDb, artifact_id: string): any | null {
+  const row = db.prepare("SELECT * FROM artifacts WHERE artifact_id = ?").get(artifact_id);
+  return (row as any) ?? null;
+}

package/src/workflow/baton.ts

@@ -0,0 +1,141 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import { clampLines, normalizeNewlines, stripCodeFences } from "../shared/text";
+import { z } from "zod";
+
+export const ASTRO_JSON_BEGIN = "<!-- ASTRO_JSON_BEGIN -->";
+export const ASTRO_JSON_END = "<!-- ASTRO_JSON_END -->";
+
+export const StageKeySchema = z.enum(["frame", "plan", "spec", "implement", "review", "verify", "close"]);
+
+export const AstroJsonSchema = z.object({
+  schema_version: z.number().int().default(1),
+
+  run_id: z.string().optional(),
+  story_key: z.string().optional(),
+
+  stage_key: StageKeySchema,
+  status: z.enum(["ok", "blocked", "failed"]).default("ok"),
+
+  summary: z.string().default(""),
+  decisions: z.array(z.string()).default([]),
+  next_actions: z.array(z.string()).default([]),
+
+  files: z.array(
+    z.object({
+      path: z.string(),
+      kind: z.string().default("file"),
+      notes: z.string().optional(),
+    })
+  ).default([]),
+
+  evidence: z.array(
+    z.object({
+      path: z.string(),
+      kind: z.string().default("evidence"),
+      notes: z.string().optional(),
+    })
+  ).default([]),
+
+  new_stories: z.array(
+    z.object({
+      title: z.string(),
+      body_md: z.string().optional(),
+      priority: z.number().int().optional(),
+    })
+  ).default([]),
+
+  questions: z.array(z.string()).default([]),
+
+  metrics: z.record(z.string(), z.union([z.number(), z.string()])).default({}),
+});
+
+export type AstroJson = z.infer<typeof AstroJsonSchema>;
+
+export type ParsedStageOutput = {
+  baton_md: string;
+  astro_json: AstroJson | null;
+  astro_json_raw: string | null;
+  error: string | null;
+};
+
+export function parseStageOutputText(text: string): ParsedStageOutput {
+  const norm = normalizeNewlines(text ?? "").trim();
+
+  const beginIdx = norm.indexOf(ASTRO_JSON_BEGIN);
+  const endIdx = norm.indexOf(ASTRO_JSON_END);
+
+  if (beginIdx === -1 || endIdx === -1 || endIdx <= beginIdx) {
+    return {
+      baton_md: norm,
+      astro_json: null,
+      astro_json_raw: null,
+      error: `Missing ASTRO JSON markers. Expected markers ${ASTRO_JSON_BEGIN} ... ${ASTRO_JSON_END}`,
+    };
+  }
+
+  const before = norm.slice(0, beginIdx).trim();
+  const jsonRaw = norm.slice(beginIdx + ASTRO_JSON_BEGIN.length, endIdx).trim();
+  const after = norm.slice(endIdx + ASTRO_JSON_END.length).trim();
+
+  const baton = [before, after].filter(Boolean).join("\n\n").trim();
+
+  try {
+    const cleaned = stripCodeFences(jsonRaw).trim();
+    const parsed = JSON.parse(cleaned) as unknown;
+    const astroJson = AstroJsonSchema.parse(parsed);
+    return { baton_md: baton, astro_json: astroJson, astro_json_raw: cleaned, error: null };
+  } catch (e) {
+    return {
+      baton_md: baton,
+      astro_json: null,
+      astro_json_raw: jsonRaw,
+      error: `Failed to parse ASTRO JSON: ${String(e)}`,
+    };
+  }
+}
+
+export function buildBatonSummary(opts: {
+  config: AstrocodeConfig;
+  stage_key: string;
+  astro_json: AstroJson | null;
+  baton_md: string;
+}): string {
+  const { config, stage_key, astro_json, baton_md } = opts;
+  const maxLines = config.context_compaction.baton_summary_max_lines;
+
+  const lines: string[] = [];
+  lines.push(`# ${stage_key} — Summary`);
+
+  if (astro_json?.summary) {
+    lines.push("", astro_json.summary.trim());
+  } else {
+    // Fallback: first non-empty paragraph
+    const paras = baton_md.split(/\n\n+/).map((p) => p.trim()).filter(Boolean);
+    if (paras[0]) lines.push("", paras[0]);
+  }
+
+  const addList = (title: string, items: string[]) => {
+    if (!items.length) return;
+    lines.push("", `## ${title}`);
+    for (const it of items.slice(0, 12)) lines.push(`- ${it}`);
+  };
+
+  addList("Decisions", astro_json?.decisions ?? []);
+  addList("Next actions", astro_json?.next_actions ?? []);
+
+  const files = astro_json?.files ?? [];
+  if (files.length) {
+    lines.push("", "## Files");
+    for (const f of files.slice(0, 15)) lines.push(`- \`${f.path}\` (${f.kind})${f.notes ? ` — ${f.notes}` : ""}`);
+  }
+
+  const evidence = astro_json?.evidence ?? [];
+  if (evidence.length) {
+    lines.push("", "## Evidence");
+    for (const ev of evidence.slice(0, 15)) lines.push(`- \`${ev.path}\` (${ev.kind})${ev.notes ? ` — ${ev.notes}` : ""}`);
+  }
+
+  const out = lines.join("\n").trim();
+  return clampLines(out, maxLines);
+}