agile-context-engineering 0.3.0 → 0.5.1

package/{commands/ace/plan-story.md → skills/plan-story/SKILL.md}

@@ -1,159 +1,139 @@
----
-name: ace:plan-story
-description: Plan a story through deep questioning to create CRYSTAL-CLEAR acceptance criteria with ZERO assumptions, then dispatch wiki research, external analysis, integration analysis, and technical solution design
-argument-hint: "story=<file-path|github-url> [external-codebase=<source-path|github-url>] [external-docs=<weblink|filepath>] [lib-docs=<weblinks-and-filepaths>]"
-allowed-tools:
-  - Read
-  - Bash
-  - Write
-  - Edit
-  - AskUserQuestion
-  - Glob
-  - Grep
-  - Agent
----
-
-```xml
-<command>
-
-    <execution-time>
-        <runs-after>
-            <trigger>After /ace:plan-feature — once a feature's story breakdown exists with stub story files</trigger>
-            <trigger>Anytime — to create or refine a story specification from a description or GitHub issue</trigger>
-        </runs-after>
-        <use-when>
-            <condition>A story stub exists (from plan-feature) and needs formal specification</condition>
-            <condition>A GitHub issue describes work that needs INVEST-compliant acceptance criteria</condition>
-            <condition>An existing story needs refinement — scope changed, AC gaps found</condition>
-            <condition>You want to create a complete story specification from any text description</condition>
-        </use-when>
-    </execution-time>
-
-    <input>
-        <flags>
-        </flags>
-
-        <parameters>
-            <required>
-                <param name="story" type="file | github-url">
-                    Story source — can be either:
-                    - **File path**: Path to a markdown file containing the story seed
-                      (typically a stub from plan-feature, or any markdown with a description)
-                    - **GitHub URL or issue number**: GitHub story reference
-                    Must be a valid, accessible file or GitHub issue.
-                    Contains the story description that will be refined through deep questioning.
-                    If not valid, stop and prompt the user.
-                </param>
-            </required>
-
-            <optional>
-                <param name="external-codebase" type="filepath | github-url">
-                    Path or GitHub repo to an external industry-standard system to analyze.
-                    When provided, pass 3 (external analysis) runs automatically.
-                    When NOT provided, the user is offered the option to provide it or skip.
-                </param>
-                <param name="external-docs" type="weblink | filepath">
-                    Link or path to external system documentation.
-                    Only used when external-codebase is also provided.
-                    Provides supplementary context for external analysis.
-                </param>
-                <param name="lib-docs" type="weblinks and/or filepaths">
-                    Space-separated string of weblinks and/or file paths to library or API documentation.
-                    These are injected into the story's Relevant Wiki section as a
-                    `### Library Documentation` subsection after pass 2 completes,
-                    so that passes 4-5 (integration analysis, technical solution) can
-                    reference them when designing the implementation.
-                    Useful for third-party libraries, SDK docs, or API references
-                    that inform how the story should be built.
-                </param>
-            </optional>
-        </parameters>
-    </input>
-
-    <execution-context>
-        <plan-story-workflow>@~/.claude/agile-context-engineering/workflows/plan-story.xml</plan-story-workflow>
-        <story-template>@~/.claude/agile-context-engineering/templates/product/story.xml</story-template>
-        <questioning>@~/.claude/agile-context-engineering/utils/questioning.xml</questioning>
-        <ui-formatting>@~/.claude/agile-context-engineering/utils/ui-formatting.md</ui-formatting>
-    </execution-context>
-
-    <output>
-        <objective>
-            Take a story seed (stub file, GitHub issue, or any text description) and produce
-            a COMPLETE story specification through deep questioning that ensures:
-            - ZERO ASSUMPTIONS — every behavior is explicitly specified
-            - CRYSTAL-CLEAR acceptance criteria with exact triggers, preconditions, outcomes
-            - INVEST compliance — Independent, Negotiable, Valuable, Estimable, Small, Testable
-            - Gherkin scenarios cover happy paths, edge cases, AND error paths
-
-            After story requirements are defined (pass 1), dispatch research passes 2-5
-            as background agents:
-            - Pass 2: Wiki research (updates story file with Relevant Wiki section)
-            - Pass 3: External analysis (OPTIONAL — creates external-analysis.md)
-            - Pass 4: Integration analysis (creates integration-analysis.md)
-            - Pass 5: Technical solution (appends to story file)
-
-            Each research pass writes directly to disk. The orchestrator context window
-            contains ONLY story requirements — research outputs do NOT flow back.
-        </objective>
-
-        <artifacts>
-            .ace/artifacts/product/&lt;id-epic_name&gt;/&lt;id-feature_name&gt;/&lt;id-story_name&gt;/&lt;id-story_name&gt;.md
-            .ace/artifacts/product/&lt;id-epic_name&gt;/&lt;id-feature_name&gt;/&lt;id-story_name&gt;/external-analysis.md (OPTIONAL)
-            .ace/artifacts/product/&lt;id-epic_name&gt;/&lt;id-feature_name&gt;/&lt;id-story_name&gt;/integration-analysis.md
-        </artifacts>
-    </output>
-
-    <process>
-        For this command use the `ace-product-owner` agent
-        that's specialized in requirements gathering, deep questioning, and story specification.
-
-        Execute the plan-story workflow from
-        `@~/.claude/agile-context-engineering/workflows/plan-story.xml` end-to-end.
-        Preserve all workflow gates (validation, approvals, commits).
-
-        **CRITICAL — Context Window Protection:**
-        Passes 2-5 run as background agents. Each agent writes output directly to files.
-        The orchestrator MUST NOT call TaskOutput on any background agent.
-        The orchestrator only needs to know when each pass finishes to start the next one.
-
-        **Pass execution order:**
-        Pass 2 + Pass 3 (if applicable) → wait → Pass 4 → wait → Pass 5 → wait → done
-    </process>
-
-    <example-usage>
-        ```
-        # From a plan-feature stub file
-        /ace:plan-story \
-          story=.ace/artifacts/product/e1-auth/f3-oauth/s1-buttons/s1-buttons.md
-
-        # From a GitHub issue
-        /ace:plan-story \
-          story=https://github.com/owner/repo/issues/95
-
-        # With external system analysis
-        /ace:plan-story \
-          story=.ace/artifacts/product/e1-charts/f2-rendering/s3-canvas/s3-canvas.md \
-          external-codebase=src/external/lightweight-charts/ \
-          external-docs=https://tradingview.github.io/lightweight-charts/
-
-        # With library documentation references
-        /ace:plan-story \
-          story=.ace/artifacts/product/e1-charts/f2-rendering/s3-canvas/s3-canvas.md \
-          lib-docs="https://docs.some-lib.io/api src/vendor/some-lib/README.md"
-
-        # With just an issue number (uses configured repo)
-        /ace:plan-story story=#95
-        ```
-    </example-usage>
-
-    <next-steps>
-        **After this command:**
-        - `/ace:execute-story story=...` — Execute the story implementation
-        - `/ace:plan-story story=...` — Plan the next story in the feature
-        - `/ace:verify-story story=...` — Verify a completed story
-        - `/ace:help` — Check project initialization status
-    </next-steps>
-
-</command>
-```
+---
+name: plan-story
+description: Plan a story through deep questioning to create CRYSTAL-CLEAR acceptance criteria with ZERO assumptions, then dispatch wiki research, external analysis, integration analysis, and technical solution design. Use this whenever the user wants to plan a story, specify a story, create acceptance criteria, refine story requirements, or take a story stub and turn it into a full specification — whether from a feature stub, GitHub issue, inline text, or from scratch.
+argument-hint: "[story=<file-path|github-url>] [text=<inline-description>] [external-codebase=<source-path|github-url>] [external-docs=<weblink|filepath>] [lib-docs=<weblinks-and-filepaths>]"
+disable-model-invocation: true
+allowed-tools: Read, Bash, Write, Edit, AskUserQuestion, Glob, Grep, Agent
+model: opus
+effort: high
+---
+
+## Environment Context (preprocessed)
+
+!`node "${CLAUDE_SKILL_DIR}/script.js" init "$ARGUMENTS" 2>/dev/null`
+
+## Supporting Resources (auto-loaded)
+
+!`cat "${CLAUDE_SKILL_DIR}/workflow.xml"`
+
+!`cat "${CLAUDE_SKILL_DIR}/story-template.xml"`
+
+!`cat "${CLAUDE_SKILL_DIR}/../../shared/utils/questioning.xml"`
+
+!`cat "${CLAUDE_SKILL_DIR}/../../shared/utils/ui-formatting.md"`
+
+```xml
+<command>
+
+    <execution-time>
+        <runs-after>
+            <trigger>After /ace:plan-feature — once a feature's story breakdown exists with stub story files</trigger>
+            <trigger>Anytime — to create or refine a story specification from a description or GitHub issue</trigger>
+        </runs-after>
+        <use-when>
+            <condition>A story stub exists (from plan-feature) and needs formal specification</condition>
+            <condition>A GitHub issue describes work that needs INVEST-compliant acceptance criteria</condition>
+            <condition>An existing story needs refinement — scope changed, AC gaps found</condition>
+            <condition>You want to create a complete story specification from any text description</condition>
+            <condition>You have a new story idea (text or no input) and need it placed in the backlog</condition>
+        </use-when>
+    </execution-time>
+
+    <input>
+        <flags>
+        </flags>
+
+        <parameters>
+            <required>
+            </required>
+
+            <optional>
+                <param name="story" type="file | github-url">
+                    Story source — can be either:
+                    - **File path**: Path to an existing markdown file containing the story seed
+                      (typically a stub from plan-feature, or any markdown with a description)
+                    - **GitHub URL or issue number**: GitHub story reference
+                    When omitted, the workflow enters "new story" mode and guides the user
+                    through backlog placement before proceeding to specification.
+                    If provided but invalid, stop and prompt the user.
+                </param>
+                <param name="text" type="text">
+                    Inline story description to seed the planning session.
+                    Used when no story file exists yet — the text becomes the initial description
+                    and the workflow asks where in the backlog this story belongs.
+                    Ignored if `story` is provided.
+                </param>
+                <param name="external-codebase" type="filepath | github-url">
+                    Path or GitHub repo to an external industry-standard system to analyze.
+                    When provided, pass 3 (external analysis) runs automatically.
+                    When NOT provided, the user is offered the option to provide it or skip.
+                </param>
+                <param name="external-docs" type="weblink | filepath">
+                    Link or path to external system documentation.
+                    Only used when external-codebase is also provided.
+                    Provides supplementary context for external analysis.
+                </param>
+                <param name="lib-docs" type="weblinks and/or filepaths">
+                    Space-separated string of weblinks and/or file paths to library or API documentation.
+                    These are injected into the story's Relevant Wiki section as a
+                    `### Library Documentation` subsection after pass 2 completes,
+                    so that passes 4-5 (integration analysis, technical solution) can
+                    reference them when designing the implementation.
+                    Useful for third-party libraries, SDK docs, or API references
+                    that inform how the story should be built.
+                </param>
+            </optional>
+        </parameters>
+    </input>
+
+    <execution-context>
+        <!-- All supporting files are auto-loaded in the Supporting Resources section above.
+             The model does NOT need to Read these files — they are already in context. -->
+    </execution-context>
+
+    <output>
+        <objective>
+            Take a story seed (stub file, GitHub issue, or any text description) and produce
+            a COMPLETE story specification through deep questioning that ensures:
+            - ZERO ASSUMPTIONS — every behavior is explicitly specified
+            - CRYSTAL-CLEAR acceptance criteria with exact triggers, preconditions, outcomes
+            - INVEST compliance — Independent, Negotiable, Valuable, Estimable, Small, Testable
+            - Gherkin scenarios cover happy paths, edge cases, AND error paths
+
+            After story requirements are defined (pass 1), dispatch research passes 2-5
+            as background agents:
+            - Pass 2: Wiki research (updates story file with Relevant Wiki section)
+            - Pass 3: External analysis (OPTIONAL — creates external-analysis.md)
+            - Pass 4: Integration analysis (creates integration-analysis.md)
+            - Pass 5: Technical solution (appends to story file)
+
+            Each research pass writes directly to disk. The orchestrator context window
+            contains ONLY story requirements — research outputs do NOT flow back.
+        </objective>
+
+        <artifacts>
+            .ace/artifacts/product/&lt;id-epic_name&gt;/&lt;id-feature_name&gt;/&lt;id-story_name&gt;/&lt;id-story_name&gt;.md
+            .ace/artifacts/product/&lt;id-epic_name&gt;/&lt;id-feature_name&gt;/&lt;id-story_name&gt;/external-analysis.md (OPTIONAL)
+            .ace/artifacts/product/&lt;id-epic_name&gt;/&lt;id-feature_name&gt;/&lt;id-story_name&gt;/integration-analysis.md
+        </artifacts>
+    </output>
+
+    <process>
+        For this command use the `ace-product-owner` agent
+        that's specialized in requirements gathering, deep questioning, and story specification.
+
+        Execute the plan-story workflow from
+        `workflow.xml` end-to-end.
+        Preserve all workflow gates (validation, approvals, commits).
+
+        **CRITICAL — Context Window Protection:**
+        Passes 2-5 run as background agents. Each agent writes output directly to files.
+        The orchestrator MUST NOT call TaskOutput on any background agent.
+        The orchestrator only needs to know when each pass finishes to start the next one.
+
+        **Pass execution order:**
+        Pass 2 + Pass 3 (if applicable) → wait → Pass 4 → wait → Pass 5 → wait → done
+    </process>
+
+    <example-usage>
+        ```

package/skills/plan-story/script.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+
+/**
+ * plan-story skill script — Entry point for all ace-tools operations
+ * needed by the plan-story skill.
+ *
+ * Subcommands:
+ *   init [story-param]        Environment detection for plan-story workflow
+ *   update-state story=X status=Y   Update story status across files
+ *   sync-github repo=X story_file=Y  Sync story/feature to GitHub
+ *   resolve-model <agent-type>       Get model for agent based on profile
+ *
+ * Usage: node script.js <subcommand> [args] [--raw]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const {
+  loadConfig, pathExists, safeReadFile, generateSlug, resolveModel,
+  detectBrownfieldStatus, loadSettings, execCommand,
+  output, error, runSkillScript,
+} = require('../../shared/lib/ace-core');
+
+const {
+  classifyStoryParam, extractStoryMetadata, extractStoryRequirements,
+  extractIssueNumber, extractIssueNumberFromFile, computeStoryPaths,
+  updateState,
+} = require('../../shared/lib/ace-story');
+
+const { syncStory, resolveFields, createIssue } = require('../../shared/lib/ace-github');
+
+// ─── CLI Dispatch ────────────────────────────────────────────────────────────
+
+runSkillScript({
+  init: cmdInit,
+  'update-state': (cwd, raw, args) => updateState(cwd, raw, args),
+  'sync-github': (cwd, raw, args) => syncStory(cwd, raw, args),
+  'resolve-model': (cwd, raw, args, parsed) => {
+    const agentType = parsed._positional || args[0];
+    if (!agentType) error('resolve-model requires agent-type argument');
+    const model = resolveModel(cwd, agentType);
+    output({ model, agent: agentType }, raw, model);
+  },
+  'generate-slug': (cwd, raw, args, parsed) => {
+    const text = parsed._positional || args.join(' ');
+    if (!text) error('generate-slug requires text argument');
+    const slug = generateSlug(text);
+    output({ slug }, raw, slug);
+  },
+  'resolve-fields': (cwd, raw, args) => resolveFields(cwd, raw, args),
+  'create-issue': (cwd, raw, args) => createIssue(cwd, raw, args),
+});
+
+// ─── Init: Plan Story ────────────────────────────────────────────────────────
+
+/**
+ * Environment detection for the plan-story workflow.
+ *
+ * Detects: git, gh CLI, GitHub project, brownfield status, wiki state,
+ * product artifacts, and story source/content/metadata.
+ *
+ * Supports three input modes:
+ *   - story param provided → loads existing file or fetches GitHub issue
+ *   - text param provided (no story) → uses inline text as seed description
+ *   - neither → new story mode, workflow handles placement
+ *
+ * initArgs: array of arguments — either a single positional path/URL,
+ *           or key=value pairs (story=X text=Y)
+ */
+function cmdInit(cwd, raw, args, parsed) {
+  const config = loadConfig(cwd);
+  const brownfield = detectBrownfieldStatus(cwd);
+
+  // ── Environment detection ──
+  const has_git = pathExists(cwd, '.git');
+  const has_gh_cli = (() => {
+    try {
+      const { execSync } = require('child_process');
+      execSync('gh --version', { stdio: 'pipe' });
+      return true;
+    } catch { return false; }
+  })();
+  const github_project = loadSettings(cwd).github_project;
+
+  // Wiki detection
+  const wikiSystemDir = '.docs/wiki/system-wide';
+  const has_wiki_system_wide = pathExists(cwd, wikiSystemDir);
+  const wikiSubsystemsDir = '.docs/wiki/subsystems';
+  const has_wiki_subsystems = pathExists(cwd, wikiSubsystemsDir);
+  let wiki_subsystem_names = [];
+  if (has_wiki_subsystems) {
+    try {
+      const entries = fs.readdirSync(path.join(cwd, wikiSubsystemsDir), { withFileTypes: true });
+      wiki_subsystem_names = entries.filter(e => e.isDirectory()).map(e => e.name);
+    } catch {}
+  }
+  const has_wiki = has_wiki_system_wide || has_wiki_subsystems;
+
+  // ── Parse input from shared parsed args ──
+  const resolvedStoryParam = parsed.story || parsed._positional || null;
+  const textParam = parsed.text || null;
+
+  // ── Base result (shared across all modes) ──
+  const baseResult = {
+    product_owner_model: resolveModel(cwd, 'ace-product-owner'),
+    commit_docs: config.commit_docs,
+    has_git, has_gh_cli, github_project,
+    ...brownfield,
+    has_wiki, has_wiki_system_wide, has_wiki_subsystems, wiki_subsystem_names,
+    has_product_vision: pathExists(cwd, '.docs/product/product-vision.md'),
+    has_product_backlog: pathExists(cwd, '.ace/artifacts/product/product-backlog.md'),
+  };
+
+  // ── Mode 1: No story param and no text → new story mode ──
+  if (!resolvedStoryParam && !textParam) {
+    output({
+      ...baseResult,
+      story_source: 'new',
+      story_valid: true,
+      story_error: null,
+      story_content: null,
+      story: { id: null, title: null, status: null, size: null, issue_number: null },
+      feature: { id: null, title: null, issue_number: null },
+      epic: { id: null, title: null },
+      user_story: null, description: null, acceptance_criteria_count: 0,
+      paths: null,
+      has_external_analysis: false, has_integration_analysis: false,
+      has_feature_file: false, has_story_file: false,
+    }, raw);
+    return;
+  }
+
+  // ── Mode 2: Text param only → use text as seed description ──
+  if (!resolvedStoryParam && textParam) {
+    output({
+      ...baseResult,
+      story_source: 'text',
+      story_valid: true,
+      story_error: null,
+      story_content: textParam,
+      story: { id: null, title: null, status: null, size: null, issue_number: null },
+      feature: { id: null, title: null, issue_number: null },
+      epic: { id: null, title: null },
+      user_story: null, description: textParam, acceptance_criteria_count: 0,
+      paths: null,
+      has_external_analysis: false, has_integration_analysis: false,
+      has_feature_file: false, has_story_file: false,
+    }, raw);
+    return;
+  }
+
+  // ── Mode 3: Story param provided → classify and load ──
+  const classified = classifyStoryParam(resolvedStoryParam);
+
+  // Invalid param
+  if (classified.type === null || classified.type === 'invalid') {
+    output({
+      ...baseResult,
+      story_source: null,
+      story_valid: false,
+      story_error: classified.reason || 'No story parameter provided',
+      story_content: null,
+      story: { id: null, title: null, status: null, size: null, issue_number: null },
+      feature: { id: null, title: null, issue_number: null },
+      epic: { id: null, title: null },
+      user_story: null, description: null, acceptance_criteria_count: 0,
+      paths: null,
+      has_external_analysis: false, has_integration_analysis: false,
+      has_feature_file: false, has_story_file: false,
+    }, raw);
+    return;
+  }
+
+  // ── Load story content ──
+  let storyContent = null;
+  let storySource = classified.type === 'file' ? 'file' : 'github';
+  let storyError = null;
+  let storyFilePath = null;
+
+  if (classified.type === 'file') {
+    const resolvedPath = path.isAbsolute(classified.filePath)
+      ? classified.filePath
+      : path.join(cwd, classified.filePath);
+    if (!pathExists(cwd, classified.filePath)) {
+      storyError = `Story file not found: ${classified.filePath}`;
+    } else {
+      storyContent = safeReadFile(resolvedPath);
+      storyFilePath = classified.filePath;
+      if (!storyContent) storyError = `Could not read story file: ${classified.filePath}`;
+    }
+  } else {
+    // github-url or issue-number
+    if (!has_gh_cli) {
+      storyError = 'GitHub CLI (gh) not installed. Cannot fetch GitHub issues.';
+    } else {
+      const repo = classified.repo || (github_project.repo || null);
+      if (!repo) {
+        storyError = 'No repository configured. Provide a full GitHub URL or configure github_project.repo in settings.';
+      } else {
+        const ghResult = execCommand(
+          `gh issue view ${classified.issueNumber} --repo ${repo} --json title,body,labels,state`,
+          cwd
+        );
+        if (!ghResult) {
+          storyError = `Could not fetch GitHub issue #${classified.issueNumber} from ${repo}.`;
+        } else {
+          try {
+            const issue = JSON.parse(ghResult);
+            storyContent = issue.body || '';
+            if (storyContent && !storyContent.match(/^#\s+/m)) {
+              storyContent = `# ${issue.title}\n\n${storyContent}`;
+            }
+          } catch {
+            storyError = `Failed to parse GitHub issue response for #${classified.issueNumber}.`;
+          }
+        }
+      }
+    }
+  }
+
+  // ── Extract metadata & requirements ──
+  const metadata = extractStoryMetadata(storyContent);
+  const requirements = extractStoryRequirements(storyContent);
+
+  // ── Compute paths ──
+  let paths = null;
+  let has_story_file = false;
+
+  if (storyFilePath) {
+    const resolvedPath = path.isAbsolute(storyFilePath)
+      ? storyFilePath
+      : path.join(cwd, storyFilePath);
+    const storyDir = path.dirname(resolvedPath);
+    const relStoryDir = path.relative(cwd, storyDir).replace(/\\/g, '/');
+    const storySlug = path.basename(storyDir);
+    const featureDir = path.dirname(storyDir);
+    const relFeatureDir = path.relative(cwd, featureDir).replace(/\\/g, '/');
+    const featureSlug = path.basename(featureDir);
+
+    paths = {
+      epic_slug: null,
+      feature_slug: featureSlug,
+      story_slug: storySlug,
+      story_dir: relStoryDir,
+      story_file: storyFilePath.replace(/\\/g, '/'),
+      external_analysis_file: `${relStoryDir}/external-analysis.md`,
+      integration_analysis_file: `${relStoryDir}/integration-analysis.md`,
+      feature_dir: relFeatureDir,
+      feature_file: `${relFeatureDir}/${featureSlug}.md`,
+    };
+    has_story_file = true;
+  } else if (metadata.epic.id && metadata.feature.id && metadata.id) {
+    paths = computeStoryPaths(
+      metadata.epic.id, metadata.epic.title || '',
+      metadata.feature.id, metadata.feature.title || '',
+      metadata.id, metadata.title || ''
+    );
+    has_story_file = paths ? pathExists(cwd, paths.story_file) : false;
+  }
+
+  // ── Check artifact existence ──
+  const has_external_analysis = paths ? pathExists(cwd, paths.external_analysis_file) : false;
+  const has_integration_analysis = paths ? pathExists(cwd, paths.integration_analysis_file) : false;
+  const has_feature_file = paths ? pathExists(cwd, paths.feature_file) : false;
+
+  // ── Build result ──
+  output({
+    ...baseResult,
+    story_source: storySource,
+    story_valid: storyContent !== null && storyError === null,
+    story_error: storyError,
+    story_content: storyContent,
+    story: {
+      id: metadata.id,
+      title: metadata.title,
+      status: metadata.status,
+      size: metadata.size,
+      issue_number: extractIssueNumber(metadata.link),
+    },
+    feature: {
+      ...metadata.feature,
+      issue_number: paths ? extractIssueNumberFromFile(cwd, paths.feature_file) : null,
+    },
+    epic: metadata.epic,
+    user_story: requirements.user_story,
+    description: requirements.description,
+    acceptance_criteria_count: requirements.acceptance_criteria_count,
+    paths,
+    has_external_analysis,
+    has_integration_analysis,
+    has_feature_file,
+    has_story_file,
+  }, raw);
+}