astrocode-workflow 0.0.1

package/LICENSE

@@ -0,0 +1 @@
+MIT

package/README.md

@@ -0,0 +1,85 @@
+# Astrocode (v2 alpha)
+
+Astrocode is a **DB-first, stage-gated agent harness** for OpenCode, rewritten in an **Oh-My-OpenCode–style plugin architecture**:
+
+- TypeScript-first implementation in `src/`
+- OpenCode `config` handler registers **one primary agent** + hidden stage subagents
+- Hooks for **continuation**, **toasts**, and **tool-output truncation**
+- A durable SQLite ledger in `.astro/astro.db` is the **source of truth**
+- Stage artifacts (batons/evidence) are written to `.astro/runs/<run_id>/...`
+
+> Design intent: *CI/CD for agent work* — auditable, resumable, deterministic progression with a “keep going” harness.
+
+## What’s included in this repo (source-only)
+
+This repository is meant to be a clean starting point for Astrocode v2:
+- No `.opencode/node_modules`
+- No hand-written `.opencode/` tools or agents
+- Everything is registered via TypeScript at runtime (like OMO)
+
+## Quick mental model
+
+- **Stories** are backlog tickets (`stories` table).
+- A **Run** is an execution attempt of a story (`runs`, `stage_runs`).
+- A **Stage** is one step of the pipeline (`frame → plan → spec → implement → review → verify → close`).
+- A **Baton** is a stage output artifact written to disk + recorded in DB (`artifacts` + `stage_runs.summary_md/output_json`).
+- **Continuation** is an explicit directive injected by hooks when a run is still active (`continuations` table).
+
+## Primary tools (high leverage)
+
+- `astro_init` — initialize `.astro/` + DB schema (idempotent)
+- `astro_status` — compact dashboard of current run/stage + next action
+- `astro_story_queue` — create a story
+- `astro_story_approve` — approve story for execution
+- `astro_workflow_proceed` — deterministic step/loop orchestrator (the main “harness” tool)
+- `astro_stage_start` — start a stage (primitive)
+- `astro_stage_complete` — complete a stage from a stage-agent output (parses `ASTRO_JSON_*` markers)
+- `astro_repair` — repair invariants / recover corrupt state
+
+Advanced (octopus) tools exist for artifacts, injects, and admin controls.
+
+## Continuation (“infinite agency”, but visible)
+
+When a run is active and a session goes idle, or a tool completes, Astrocode injects a **visible** directive like:
+
+`[SYSTEM DIRECTIVE: ASTROCODE — CONTINUE]`
+
+This directive is deduped (hashed + recorded in DB) to avoid spam loops.
+
+You can optionally enable bounded auto-continue (rate-limit safe) in config.
+
+## Installation
+
+Add to your OpenCode config (`~/.config/opencode/opencode.json`):
+
+```json
+{
+  "plugin": [
+    "astrocode-harness"
+  ]
+}
+```
+
+Then start OpenCode - it will install the plugin automatically.
+
+## Configuration
+
+Project config is read from:
+
+- `.astro/astrocode.config.jsonc` (preferred)
+- `astrocode.config.jsonc` (fallback)
+
+Config is validated (Zod via `@opencode-ai/plugin/tool.schema`) and merged with defaults.
+
+## Development
+
+```bash
+npm install
+npm run build
+```
+
+> NOTE: This repo depends on `better-sqlite3` (native). It is a deliberate v2-alpha choice for performance and DB ergonomics. Backend abstraction is structured so swapping to `bun:sqlite` or `node:sqlite` is straightforward later.
+
+## License
+
+MIT

package/dist/agents/commands.d.ts

@@ -0,0 +1,9 @@
+import type { AstrocodeConfig } from "../config/schema";
+export type CommandDefinition = {
+    description: string;
+    template: string;
+    argumentHint?: string;
+};
+export declare function createAstroCommands(_opts: {
+    pluginConfig: AstrocodeConfig;
+}): Record<string, CommandDefinition>;

package/dist/agents/commands.js

@@ -0,0 +1,121 @@
+export function createAstroCommands(_opts) {
+    // Keep templates very short: they just steer toward tools.
+    return {
+        "astro": {
+            description: "Astrocode help.",
+            argumentHint: "",
+            template: `<command-instruction>
+You are using Astrocode vNext.
+Show a short help message with the key commands:
+- /astro-status
+- /astro-init
+- /astro-queue \"title\" --body=\"...\" 
+- /astro-approve S-123
+- /astro-next
+- /astro-loop --max-steps=50
+- /astro-repair
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-status": {
+            description: "Show Astrocode status: current run, stage, blockers, next action.",
+            argumentHint: "",
+            template: `<command-instruction>
+Call tool astro_status.
+Return a compact dashboard.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-init": {
+            description: "Initialize Astrocode (.astro directory + SQLite DB).",
+            argumentHint: "",
+            template: `<command-instruction>
+Call tool astro_init.
+Then call astro_status.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-queue": {
+            description: "Create a queued story.",
+            argumentHint: "\"title\" --body=\"...\" --priority=50",
+            template: `<command-instruction>
+Create a story using astro_story_queue.
+Title is required. Body optional.
+Return story_key.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-approve": {
+            description: "Approve a story so it can be run.",
+            argumentHint: "S-123",
+            template: `<command-instruction>
+Call astro_story_approve with story_key.
+Then call astro_status.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-next": {
+            description: "Advance Astrocode by one deterministic step.",
+            argumentHint: "",
+            template: `<command-instruction>
+Call tool astro_workflow_proceed with mode=step.
+If it injects a CONTINUE directive, obey it.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-loop": {
+            description: "Run Astrocode loop for N steps (bounded).",
+            argumentHint: "--max-steps=N",
+            template: `<command-instruction>
+Parse --max-steps (default 50).
+Call tool astro_workflow_proceed with mode=loop and max_steps.
+Stop if blocked.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-repair": {
+            description: "Repair invariants / recover from inconsistent state.",
+            argumentHint: "",
+            template: `<command-instruction>
+Call astro_repair.
+Return repair report summary + pointers.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-board": {
+            description: "Show story board grouped by state.",
+            argumentHint: "",
+            template: `<command-instruction>
+Call astro_story_board.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+    };
+}

package/dist/agents/prompts.d.ts

@@ -0,0 +1,2 @@
+export declare const BASE_ORCH_PROMPT = "You are Astro (Orchestrator) for Astrocode.\n\nMission:\n- Advance a deterministic pipeline: frame \u2192 plan \u2192 spec \u2192 implement \u2192 review \u2192 verify \u2192 close.\n- The SQLite DB is the source of truth. Prefer tools over prose.\n- Never narrate what prompts you received.\n- Keep outputs short; store large outputs as artifacts and reference paths.\n\nOperating rules:\n- Prefer calling astro_workflow_proceed (step/loop) and astro_status.\n- Delegate stage work only to the stage subagent matching the current stage.\n- If a stage subagent returns status=blocked, inject the BLOCKED directive and stop.\n- Never delegate from subagents (enforced by permissions).\n";
+export declare const BASE_STAGE_PROMPT = "You are an Astro stage subagent.\n\nFollow the latest [SYSTEM DIRECTIVE: ASTROCODE \u2014 STAGE_*] you receive.\n\nOutput exactly:\n1) Baton markdown (short, structured)\n2) Valid ASTRO JSON between markers:\n<!-- ASTRO_JSON_BEGIN -->\n{...}\n<!-- ASTRO_JSON_END -->\n\nDo not narrate. If blocked, ask exactly ONE question and stop.\n";

package/dist/agents/prompts.js

@@ -0,0 +1,27 @@
+export const BASE_ORCH_PROMPT = `You are Astro (Orchestrator) for Astrocode.
+
+Mission:
+- Advance a deterministic pipeline: frame → plan → spec → implement → review → verify → close.
+- The SQLite DB is the source of truth. Prefer tools over prose.
+- Never narrate what prompts you received.
+- Keep outputs short; store large outputs as artifacts and reference paths.
+
+Operating rules:
+- Prefer calling astro_workflow_proceed (step/loop) and astro_status.
+- Delegate stage work only to the stage subagent matching the current stage.
+- If a stage subagent returns status=blocked, inject the BLOCKED directive and stop.
+- Never delegate from subagents (enforced by permissions).
+`;
+export const BASE_STAGE_PROMPT = `You are an Astro stage subagent.
+
+Follow the latest [SYSTEM DIRECTIVE: ASTROCODE — STAGE_*] you receive.
+
+Output exactly:
+1) Baton markdown (short, structured)
+2) Valid ASTRO JSON between markers:
+<!-- ASTRO_JSON_BEGIN -->
+{...}
+<!-- ASTRO_JSON_END -->
+
+Do not narrate. If blocked, ask exactly ONE question and stop.
+`;

package/dist/agents/registry.d.ts

@@ -0,0 +1,6 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AstrocodeConfig } from "../config/schema";
+export declare function createAstroAgents(opts: {
+    systemDefaultModel: string;
+    pluginConfig: AstrocodeConfig;
+}): Record<string, AgentConfig>;

package/dist/agents/registry.js

@@ -0,0 +1,223 @@
+import { applyModelTuning } from "../shared/model-tuning";
+import { BASE_ORCH_PROMPT, BASE_STAGE_PROMPT } from "./prompts";
+function denyAll() {
+    return { "*": "deny" };
+}
+function orchestratorPermissions() {
+    return {
+        "*": "deny",
+        // Common OpenCode tools:
+        "read": "allow",
+        "grep": "allow",
+        "bash": "allow",
+        "edit": "allow",
+        "write": "allow",
+        "question": "allow",
+        // Task delegation:
+        "task": "allow",
+        "delegate_task": "allow",
+        "slashcommand": "allow",
+        // Astro tools:
+        "astro_init": "allow",
+        "astro_status": "allow",
+        "astro_workflow_proceed": "allow",
+        "astro_repair": "allow",
+        "astro_spec_get": "allow",
+        "astro_spec_set": "allow",
+        "astro_story_queue": "allow",
+        "astro_story_approve": "allow",
+        "astro_story_board": "allow",
+        "astro_story_set_state": "allow",
+        "astro_run_get": "allow",
+        "astro_run_abort": "allow",
+        "astro_stage_start": "allow",
+        "astro_stage_complete": "allow",
+        "astro_stage_fail": "allow",
+        "astro_stage_reset": "allow",
+        "astro_artifact_put": "allow",
+        "astro_artifact_list": "allow",
+        "astro_artifact_get": "allow",
+        "astro_inject_put": "allow",
+        "astro_inject_list": "allow",
+        "astro_inject_search": "allow",
+        "astro_inject_get": "allow",
+        // Git helpers (optional)
+        "astro_git_status": "allow",
+        "astro_git_diff": "allow",
+        "astro_git_commit": "ask",
+    };
+}
+function stageReadOnlyPermissions() {
+    return {
+        "*": "deny",
+        "read": "allow",
+        "grep": "allow",
+        "question": "allow",
+        "task": "deny",
+        "delegate_task": "deny",
+        "slashcommand": "deny",
+    };
+}
+function stageImplementPermissions() {
+    return {
+        "*": "deny",
+        "read": "allow",
+        "grep": "allow",
+        "edit": "allow",
+        "write": "allow",
+        "bash": "allow",
+        "question": "allow",
+        "task": "deny",
+        "delegate_task": "deny",
+        "slashcommand": "deny",
+        "astro_artifact_put": "allow",
+        "astro_artifact_list": "allow",
+        "astro_artifact_get": "allow",
+        "astro_git_diff": "allow",
+    };
+}
+function stageVerifyPermissions() {
+    return {
+        "*": "deny",
+        "read": "allow",
+        "grep": "allow",
+        "bash": "allow",
+        "question": "allow",
+        "task": "deny",
+        "delegate_task": "deny",
+        "slashcommand": "deny",
+        "astro_artifact_put": "allow",
+        "astro_artifact_list": "allow",
+        "astro_artifact_get": "allow",
+    };
+}
+export function createAstroAgents(opts) {
+    const { systemDefaultModel, pluginConfig } = opts;
+    // Ensure agents config exists with defaults
+    if (!pluginConfig.agents) {
+        pluginConfig.agents = {
+            orchestrator_name: "Astro",
+            stage_agent_names: {
+                frame: "AstroFrame",
+                plan: "AstroPlan",
+                spec: "AstroSpec",
+                implement: "AstroImplement",
+                review: "AstroReview",
+                verify: "AstroVerify",
+                close: "AstroClose"
+            },
+            librarian_name: "AstroLibrarian",
+            explore_name: "AstroExplore",
+            agent_variant_overrides: {}
+        };
+    }
+    const orchestratorName = pluginConfig.agents.orchestrator_name;
+    const modelFor = (agentName) => {
+        const overrides = pluginConfig.agents?.agent_variant_overrides || {};
+        const override = overrides[agentName];
+        return override?.model;
+    };
+    const variantFor = (agentName) => {
+        const overrides = pluginConfig.agents?.agent_variant_overrides || {};
+        const override = overrides[agentName];
+        return override?.variant;
+    };
+    const mk = (name, base, preset) => {
+        const tuned = applyModelTuning(base, preset);
+        // Apply per-agent model/variant overrides from config:
+        const withOverrides = {
+            ...tuned,
+            model: modelFor(name),
+            variant: variantFor(name),
+        };
+        return withOverrides;
+    };
+    const agents = {};
+    agents[orchestratorName] = mk(orchestratorName, {
+        description: "Astrocode vNext orchestrator. DB-driven stage machine with continuation + artifact discipline.",
+        mode: "primary",
+        maxTokens: 32000,
+        prompt: BASE_ORCH_PROMPT,
+        permission: orchestratorPermissions(),
+    }, "orchestrator");
+    // Stage agents (hidden)
+    const stageAgents = pluginConfig.agents.stage_agent_names;
+    agents[stageAgents.frame] = mk(stageAgents.frame, {
+        description: "Stage agent: frame. Produces scope + DoD baton.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "frame");
+    agents[stageAgents.plan] = mk(stageAgents.plan, {
+        description: "Stage agent: plan. Produces bounded tasks + files + tests.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "plan");
+    agents[stageAgents.spec] = mk(stageAgents.spec, {
+        description: "Stage agent: spec. Produces implementation contracts (minimal).",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "spec");
+    agents[stageAgents.implement] = mk(stageAgents.implement, {
+        description: "Stage agent: implement. Makes code changes and references diff artifacts.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.2,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageImplementPermissions(),
+    }, "implement");
+    agents[stageAgents.review] = mk(stageAgents.review, {
+        description: "Stage agent: review. Checks spec compliance and risks.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "review");
+    agents[stageAgents.verify] = mk(stageAgents.verify, {
+        description: "Stage agent: verify. Runs checks and produces evidence artifacts.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "verify");
+    agents[stageAgents.close] = mk(stageAgents.close, {
+        description: "Stage agent: close. Final run summary + acceptance confirmation.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "close");
+    // Optional utility agents (hidden) — intentionally minimal prompt; prefer stage directives.
+    agents[pluginConfig.agents.librarian_name] = mk(pluginConfig.agents.librarian_name, {
+        description: "Utility agent: librarian. Fast repo exploration + notes as artifacts.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "utility");
+    agents[pluginConfig.agents.explore_name] = mk(pluginConfig.agents.explore_name, {
+        description: "Utility agent: explore. Spikes / scans / code search.",
+        mode: "subagent",
+        hidden: true,
+        temperature: 0.1,
+        prompt: BASE_STAGE_PROMPT,
+        permission: stageReadOnlyPermissions(),
+    }, "utility");
+    // Allow user config to disable certain agents
+    for (const disabled of pluginConfig.disabled_agents) {
+        delete agents[disabled];
+    }
+    return agents;
+}

package/dist/agents/types.d.ts

@@ -0,0 +1,14 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+/**
+ * Matches OMO-style heuristics:
+ * - OpenAI provider models: "openai/..."
+ * - GitHub Copilot GPT models: "github-copilot/gpt-..."
+ */
+export declare function isGptModel(model: string): boolean;
+export type AstroAgentName = "Astro (Orchestrator)" | "astro_frame" | "astro_plan" | "astro_spec" | "astro_implement" | "astro_review" | "astro_verify" | "astro_close" | "astro_librarian" | "astro_explore";
+export type PermissionValue = "ask" | "allow" | "deny";
+export type AgentOverrideConfig = Partial<AgentConfig> & {
+    prompt_append?: string;
+    variant?: string;
+};
+export type AgentOverrides = Partial<Record<AstroAgentName, AgentOverrideConfig>>;

package/dist/agents/types.js

@@ -0,0 +1,8 @@
+/**
+ * Matches OMO-style heuristics:
+ * - OpenAI provider models: "openai/..."
+ * - GitHub Copilot GPT models: "github-copilot/gpt-..."
+ */
+export function isGptModel(model) {
+    return model.startsWith("openai/") || model.startsWith("github-copilot/gpt-");
+}

package/dist/config/config-handler.d.ts

@@ -0,0 +1,4 @@
+import type { AstrocodeConfig } from "./schema";
+export declare function createConfigHandler(opts: {
+    pluginConfig: AstrocodeConfig;
+}): (config: Record<string, any>) => Promise<void>;

package/dist/config/config-handler.js

@@ -0,0 +1,46 @@
+import { createAstroAgents } from "../agents/registry";
+import { createAstroCommands } from "../agents/commands";
+/** Best-effort extraction of system default model from an OpenCode config object. */
+function detectSystemDefaultModel(config) {
+    const direct = config?.model;
+    if (typeof direct === "string" && direct.trim())
+        return direct.trim();
+    const agentDefault = config?.agent?.default?.model;
+    if (typeof agentDefault === "string" && agentDefault.trim())
+        return agentDefault.trim();
+    const firstAgent = config?.agent && typeof config.agent === "object" ? Object.values(config.agent)[0] : null;
+    const firstModel = firstAgent?.model;
+    if (typeof firstModel === "string" && firstModel.trim())
+        return firstModel.trim();
+    return "openai/gpt-4o";
+}
+export function createConfigHandler(opts) {
+    const { pluginConfig } = opts;
+    return async function configHandler(config) {
+        try {
+            const systemDefaultModel = detectSystemDefaultModel(config);
+            const agents = createAstroAgents({ systemDefaultModel, pluginConfig });
+            const commands = createAstroCommands({ pluginConfig });
+            // Merge agents (do not override user-defined agent configs with same key; user wins)
+            config.agent = config.agent ?? {};
+            for (const [name, agentCfg] of Object.entries(agents)) {
+                if (pluginConfig.disabled_agents?.includes(name))
+                    continue;
+                if (!config.agent[name])
+                    config.agent[name] = agentCfg;
+            }
+            // Merge commands (user wins)
+            config.command = config.command ?? {};
+            for (const [name, cmd] of Object.entries(commands)) {
+                if (pluginConfig.disabled_commands?.includes(name))
+                    continue;
+                if (!config.command[name])
+                    config.command[name] = cmd;
+            }
+        }
+        catch (e) {
+            console.warn("[astrocode] Config handler failed:", e);
+            // Don't crash OpenCode, just skip config modifications
+        }
+    };
+}

package/dist/config/defaults.d.ts

@@ -0,0 +1,3 @@
+import { type AstrocodeConfig } from "./schema";
+/** Concrete defaults object (post-Zod defaults). */
+export declare const DEFAULT_CONFIG: AstrocodeConfig;

package/dist/config/defaults.js

@@ -0,0 +1,3 @@
+import { AstrocodeConfigSchema } from "./schema";
+/** Concrete defaults object (post-Zod defaults). */
+export const DEFAULT_CONFIG = AstrocodeConfigSchema.parse({});

package/dist/config/loader.d.ts

@@ -0,0 +1,11 @@
+import { type AstrocodeConfig } from "./schema";
+export type ConfigFileDetection = {
+    format: "jsonc" | "json";
+    path: string;
+} | {
+    format: "none";
+    path: string;
+};
+export declare function detectConfigFile(basePathNoExt: string): ConfigFileDetection;
+export declare function loadConfigFromPath(p: string): AstrocodeConfig | null;
+export declare function loadAstrocodeConfig(repoRoot: string): AstrocodeConfig;

package/dist/config/loader.js

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
+import { AstrocodeConfigSchema } from "./schema";
+import { deepMerge } from "../shared/deep-merge";
+import { warn } from "../shared/log";
+export function detectConfigFile(basePathNoExt) {
+    const jsoncPath = basePathNoExt + ".jsonc";
+    if (fs.existsSync(jsoncPath))
+        return { format: "jsonc", path: jsoncPath };
+    const jsonPath = basePathNoExt + ".json";
+    if (fs.existsSync(jsonPath))
+        return { format: "json", path: jsonPath };
+    return { format: "none", path: basePathNoExt + ".jsonc" };
+}
+export function loadConfigFromPath(p) {
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const raw = fs.readFileSync(p, "utf-8");
+        const parsed = parseJsonc(raw);
+        const cfg = AstrocodeConfigSchema.parse(parsed);
+        return cfg;
+    }
+    catch (e) {
+        warn(`Failed to load astrocode config at ${p}; using defaults`, String(e));
+        return null;
+    }
+}
+export function loadAstrocodeConfig(repoRoot) {
+    // project-level: prefer .astro/astrocode.config.jsonc; fallback astrocode.config.jsonc
+    const projectBase = path.join(repoRoot, ".astro", "astrocode.config");
+    const projectDetected = detectConfigFile(projectBase);
+    const projectCfg = loadConfigFromPath(projectDetected.path);
+    const legacyBase = path.join(repoRoot, "astrocode.config");
+    const legacyDetected = detectConfigFile(legacyBase);
+    const legacyCfg = loadConfigFromPath(legacyDetected.path);
+    // Start with defaults and merge configs
+    let cfg = AstrocodeConfigSchema.parse({});
+    if (legacyCfg)
+        cfg = deepMerge(cfg, legacyCfg);
+    if (projectCfg)
+        cfg = deepMerge(cfg, projectCfg);
+    // Ensure the final config is fully validated with all required defaults
+    cfg = AstrocodeConfigSchema.parse(cfg);
+    // Config loaded successfully (silent)
+    return cfg;
+}