diff --git a/README.md b/README.md
index d0cf165..408d1fa 100644
--- a/README.md
+++ b/README.md
@@ -22,9 +22,10 @@ task build
 
 ```
 ./bauer --doc-id <doc-id> \
-  --credentials <path-to-creds> \
-  --parse-only
+  --credentials <path-to-creds>
+  --github-repo <github-repo>
 ```
+Additionally, you can run it with `--parse-only` without creeting an issue.
 
 
 ## Configuration
@@ -39,27 +40,55 @@ cp credentials.example.json credentials.json
 ## Usage
 
 1.  Build Bauer locally using the Local development steps above (`task build`)
-2. If running with GitHub integration (no `--parse-only`), ensure `copilot` is installed and authenticated
+2. If running with GitHub issue creation (no `--parse-only`), ensure GitHub CLI auth is available
 3. Get document ID from Google Document & share the document with the service account
 4. Run Bauer
 
+### GitHub CLI authentication
+
+Run these once before using parse-and-issue mode:
+
+```bash
+gh auth login
+gh auth status
+```
+
+If you prefer token auth in non-interactive environments:
+
+```bash
+export GH_TOKEN=<your_token>
+gh auth status
+```
+
 ```bash
 ./bauer --doc-id <your-document-id> --credentials ./credentials.json
 ```
 
 5. Optional parameters
 
-| Flag               | Type   | Default              | Description                                                                     | Requires Copilot |
-| ------------------ | ------ | -------------------- | ------------------------------------------------------------------------------- | ---------------- |
+| Flag               | Type   | Default              | Description                                                                     | Requires GitHub Auth |
+| ------------------ | ------ | -------------------- | ------------------------------------------------------------------------------- | -------------------- |
 | `--github-repo`    | string | (required if not parse-only) | GitHub repository (owner/repo or HTTPS URL)                              | Yes*             |
 | `--credentials`    | string | `bau-test-creds.json` | Path to service account credentials JSON                                       | No               |
 | `--local-repo-path` | string | `/tmp/ubuntu.com`    | Local path for cloned repository                                               | No               |
-| `--dry-run`        | bool   | `false`              | Perform a dry run without creating PR                                          | Yes*             |
 | `--output-dir`     | string | `bauer-output`       | Output directory for Bauer results                                             | No               |
 | `--branch-prefix`  | string | `bauer`              | Branch naming prefix                                                            | No               |
-| `--parse-only`     | bool   | `false`              | Parse document and output machine-readable JSON (skip GitHub integration) | No               |
+| `--parse-only`     | bool   | `false`              | Parse document and output machine-readable JSON only                           | No               |
+
+Current execution modes:
+
+1. Parse-only mode (`--parse-only`)
+- Creates `bauer-output/bauer-parse-result.json`
+- Does not push branches
+- Does not create issues
+
+2. Parse-and-issue mode (without `--parse-only`)
+- Creates `bauer-output/bauer-parse-result.json`
+- Creates a branch and pushes the parse file into that branch
+- Opens a GitHub issue assigned to Copilot (with fallbacks) and includes branch/pinned/raw links to the prompt file
+
+*GitHub auth is only required when using parse-and-issue mode.
 
-*These flags require Copilot integration to be configured when performing GitHub operations (not needed for `--parse-only`)
 <!-- ### Examples
 
 #### Basic run
@@ -68,12 +97,20 @@ cp credentials.example.json credentials.json
 bauer --doc-id <your-document-id> --credentials ./credentials.json
 ```
 
-#### Dry run (test without executing changes)
+#### Parse only
+
+```bash
+bauer --doc-id <your-document-id> \
+        --credentials ./credentials.json \
+        --parse-only
+```
+
+#### Parse and create issue
 
 ```bash
 bauer --doc-id <your-document-id> \
         --credentials ./credentials.json \
-        --dry-run
+        --github-repo owner/repo
 ```
 
 #### Custom chunk size and output directory
diff --git a/cmd/app/types/config.go b/cmd/app/types/config.go
index 443c7f0..0826f1a 100644
--- a/cmd/app/types/config.go
+++ b/cmd/app/types/config.go
@@ -14,14 +14,6 @@ type APIConfig struct {
 	// Default is "bauer-output" if not specified.
 	BaseOutputDir string
 
-	// Model is the Copilot model to use for sessions.
-	// Default is "gpt-5-mini-high" if not specified.
-	Model string
-
-	// SummaryModel is the Copilot model to use for the summary session.
-	// Default is "gpt-5-mini-high" if not specified.
-	SummaryModel string
-
 	// TargetRepo is the path (relative or absolute) to the target repository
 	// where tasks should be executed. If not specified, uses the current directory.
 	TargetRepo string `json:"target_repo"`
@@ -30,8 +22,6 @@ type APIConfig struct {
 func LoadConfig() (*APIConfig, error) {
 	credentialsPath := flag.String("credentials", "", "Path to service account JSON (required)")
 	baseOutputDir := flag.String("base-output-dir", "bauer-output", "Base path of directory for generated prompt files (default: bauer-output)")
-	model := flag.String("model", "gpt-5-mini-high", "Copilot model to use for sessions (default: gpt-5-mini-high)")
-	summaryModel := flag.String("summary-model", "gpt-5-mini-high", "Copilot model to use for summary session (default: gpt-5-mini-high)")
 	configFile := flag.String("config", "", "Path to JSON config file")
 	targetRepo := flag.String("target-repo", "", "Path to target repository where tasks should be executed (default: current directory)")
 
@@ -45,8 +35,6 @@ func LoadConfig() (*APIConfig, error) {
 		return &APIConfig{
 			CredentialsPath: cfg.CredentialsPath,
 			BaseOutputDir:   cfg.OutputDir,
-			Model:           cfg.Model,
-			SummaryModel:    cfg.SummaryModel,
 			TargetRepo:      cfg.TargetRepo,
 		}, nil
 	}
@@ -59,8 +47,6 @@ func LoadConfig() (*APIConfig, error) {
 	cfg := &APIConfig{
 		CredentialsPath: *credentialsPath,
 		BaseOutputDir:   *baseOutputDir,
-		Model:           *model,
-		SummaryModel:    *summaryModel,
 		TargetRepo:      *targetRepo,
 	}
 
diff --git a/cmd/app/v1/api.go b/cmd/app/v1/api.go
index 2031ae8..78fb022 100644
--- a/cmd/app/v1/api.go
+++ b/cmd/app/v1/api.go
@@ -38,8 +38,6 @@ func JobPost(rc types.RouteConfig) func(w http.ResponseWriter, r *http.Request)
 			PageRefresh:     payload.PageRefresh,
 			CredentialsPath: rc.APIConfig.CredentialsPath,
 			OutputDir:       fmt.Sprintf("%s/%s", rc.APIConfig.BaseOutputDir, requestID),
-			Model:           rc.APIConfig.Model,
-			SummaryModel:    rc.APIConfig.SummaryModel,
 		}
 
 		go executeJob(requestID, cfg, rc)
diff --git a/cmd/bauer/main.go b/cmd/bauer/main.go
index 40d5eb9..38acf59 100644
--- a/cmd/bauer/main.go
+++ b/cmd/bauer/main.go
@@ -17,8 +17,7 @@ func main() {
 	docID := flag.String("doc-id", "", "Google Doc ID")
 	credentialsPath := flag.String("credentials", "bau-test-creds.json", "Path to service account credentials JSON")
 	localRepoPath := flag.String("local-repo-path", "/tmp/ubuntu.com", "Local path for cloned repository")
-	dryRun := flag.Bool("dry-run", false, "Perform a dry run without creating PR")
-	parseOnly := flag.Bool("parse-only", false, "Phase 1: Parse document and output machine-readable JSON (skip GitHub integration)")
+	parseOnly := flag.Bool("parse-only", false, "Parse document and output machine-readable JSON only")
 	outputDir := flag.String("output-dir", "bauer-output", "Output directory for Bauer results")
 	branchPrefix := flag.String("branch-prefix", "bauer", "Branch naming prefix")
 
@@ -43,7 +42,7 @@ func main() {
 
 	// Create workflow input from CLI flags/config
 	ghToken := ""
-	if !*parseOnly {
+	if *githubRepo != "" {
 		var err error
 		ghToken, err = github.GetGitHubToken()
 		if err != nil {
@@ -58,7 +57,6 @@ func main() {
 		DocID:         *docID,
 		Credentials:   *credentialsPath,
 		LocalRepoPath: *localRepoPath,
-		DryRun:        *dryRun,
 		ParseOnly:     *parseOnly,
 		OutputDir:     *outputDir,
 	}
@@ -78,7 +76,8 @@ func main() {
 		fmt.Printf("Output file: %s\n", result.OutputFile)
 	} else {
 		fmt.Printf("Status: %s\n", result.Status)
+		fmt.Printf("Output file: %s\n", result.OutputFile)
 		fmt.Printf("Branch: %s\n", result.RepositoryInfo.BranchName)
-		fmt.Printf("PR: %s\n", result.FinalizationInfo.PullRequest.URL)
+		fmt.Printf("Issue: %s\n", result.FinalizationInfo.Issue.URL)
 	}
 }
diff --git a/credentials.example.json b/credentials.example.json
deleted file mode 100644
index 740ee7f..0000000
--- a/credentials.example.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "type": "service_account",
-  "project_id": "",
-  "private_key_id": "",
-  "private_key": "",
-  "client_email": "",
-  "client_id": "",
-  "auth_uri": "",
-  "token_uri": "",
-  "auth_provider_x509_cert_url": "",
-  "client_x509_cert_url": "",
-  "universe_domain": ""
-}
\ No newline at end of file
diff --git a/google-credentials-example.json b/google-credentials-example.json
new file mode 100644
index 0000000..4ede789
--- /dev/null
+++ b/google-credentials-example.json
@@ -0,0 +1,7 @@
+{
+  "type": "service_account",
+  "project_id": "",
+  "private_key": "",
+  "client_email": "",
+  "token_uri": ""
+}
\ No newline at end of file
diff --git a/internal/config/cli.go b/internal/config/cli.go
index dc4f846..39630e1 100644
--- a/internal/config/cli.go
+++ b/internal/config/cli.go
@@ -17,12 +17,10 @@ func Load() (*Config, error) {
 	docID := flag.String("doc-id", "", "Google Doc ID to extract feedback from (required)")
 	credentialsPath := flag.String("credentials", "", "Path to service account JSON (required)")
 	configFile := flag.String("config", "", "Path to JSON config file")
-	dryRun := flag.Bool("dry-run", false, "Run extraction and planning only; skip Copilot and PR creation")
+	parseOnly := flag.Bool("parse-only", false, "Parse document to JSON only; skip GitHub integration")
 	chunkSize := flag.Int("chunk-size", 0, "Total number of chunks to create (default: 1, or 5 if --page-refresh is set)")
 	pageRefresh := flag.Bool("page-refresh", false, "Use page refresh mode with page-refresh-instructions template (default chunk size: 5)")
 	outputDir := flag.String("output-dir", "bauer-output", "Directory for generated prompt files (default: bauer-output)")
-	model := flag.String("model", "gpt-5-mini-high", "Copilot model to use for sessions (default: gpt-5-mini-high)")
-	summaryModel := flag.String("summary-model", "gpt-5-mini-high", "Copilot model to use for summary session (default: gpt-5-mini-high)")
 	targetRepo := flag.String("target-repo", "", "Path to target repository where tasks should be executed (default: current directory)")
 
 	// Custom usage message
@@ -40,12 +38,10 @@ func Load() (*Config, error) {
 			{"--config", "<string>", "Path to JSON config file"},
 			{"--doc-id", "<string>", "Google Doc ID to extract feedback from (required)"},
 			{"--credentials", "<string>", "Path to service account JSON (required)"},
-			{"--dry-run", "", "Run extraction and planning only; skip Copilot and PR creation"},
+			{"--parse-only", "", "Parse document to JSON only; skip GitHub integration"},
 			{"--page-refresh", "", "Use page refresh mode with page-refresh-instructions template"},
 			{"--chunk-size", "<int>", "Total number of chunks to create (default: 1, or 5 if --page-refresh is set)"},
 			{"--output-dir", "<string>", "Directory for generated prompt files (default: bauer-output)"},
-			{"--model", "<string>", "Copilot model to use for sessions (default: gpt-5-mini-high)"},
-			{"--summary-model", "<string>", "Copilot model to use for summary session (default: gpt-5-mini-high)"},
 			{"--target-repo", "<string>", "Path to target repository where tasks should be executed (default: current directory)"},
 		}
 
@@ -76,12 +72,10 @@ func Load() (*Config, error) {
 	cfg := &Config{
 		DocID:           *docID,
 		CredentialsPath: *credentialsPath,
-		DryRun:          *dryRun,
+		ParseOnly:       *parseOnly,
 		ChunkSize:       *chunkSize,
 		PageRefresh:     *pageRefresh,
 		OutputDir:       *outputDir,
-		Model:           *model,
-		SummaryModel:    *summaryModel,
 		TargetRepo:      *targetRepo,
 	}
 
diff --git a/internal/config/config.go b/internal/config/config.go
index b768eab..5008258 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -15,10 +15,7 @@ type Config struct {
 	// CredentialsPath is the path to the Google Cloud service account JSON key file.
 	CredentialsPath string `json:"credentials"`
 
-	// DryRun indicates if the tool should skip side-effect operations (Copilot CLI, PR creation).
-	DryRun bool `json:"dry_run"`
-
-	// ParseOnly indicates Phase 1 mode - parse document only, skip Copilot execution and GitHub integration
+	// ParseOnly indicates Phase 1 mode - parse document only, skip GitHub integration
 	ParseOnly bool `json:"parse_only"`
 
 	// ChunkSize is the total number of chunks to create from all locations.
@@ -33,14 +30,6 @@ type Config struct {
 	// Default is "bauer-output" if not specified.
 	OutputDir string `json:"output_dir"`
 
-	// Model is the Copilot model to use for sessions.
-	// Default is "gpt-5-mini-high" if not specified.
-	Model string `json:"model"`
-
-	// SummaryModel is the Copilot model to use for the summary session.
-	// Default is "gpt-5-mini-high" if not specified.
-	SummaryModel string `json:"summary_model"`
-
 	// TargetRepo is the path (relative or absolute) to the target repository
 	// where tasks should be executed. If not specified, uses the current directory.
 	TargetRepo string `json:"target_repo"`
@@ -58,12 +47,6 @@ func (c *Config) ApplyDefaults() {
 	if c.OutputDir == "" {
 		c.OutputDir = "bauer-output"
 	}
-	if c.Model == "" {
-		c.Model = "gpt-5-mini-high"
-	}
-	if c.SummaryModel == "" {
-		c.SummaryModel = "gpt-5-mini-high"
-	}
 }
 
 // Validate checks if the configuration is valid.
diff --git a/internal/config/config_test.go b/internal/config/config_test.go
index 22e95c7..0e85aa4 100644
--- a/internal/config/config_test.go
+++ b/internal/config/config_test.go
@@ -26,8 +26,6 @@ func TestConfig_Validate(t *testing.T) {
 				CredentialsPath: validCredsFile,
 				ChunkSize:       1,
 				OutputDir:       "bauer-output",
-				Model:           "gpt-4",
-				SummaryModel:    "gpt-4",
 			},
 			wantErr: false,
 		},
@@ -37,8 +35,6 @@ func TestConfig_Validate(t *testing.T) {
 				DocID:           "",
 				CredentialsPath: validCredsFile,
 				ChunkSize:       1,
-				Model:           "gpt-4",
-				SummaryModel:    "gpt-4",
 			},
 			wantErr: true,
 		},
@@ -48,8 +44,6 @@ func TestConfig_Validate(t *testing.T) {
 				DocID:           "some-doc-id",
 				CredentialsPath: "",
 				ChunkSize:       1,
-				Model:           "gpt-4",
-				SummaryModel:    "gpt-4",
 			},
 			wantErr: true,
 		},
@@ -59,8 +53,6 @@ func TestConfig_Validate(t *testing.T) {
 				DocID:           "some-doc-id",
 				CredentialsPath: filepath.Join(tmpDir, "non-existent.json"),
 				ChunkSize:       1,
-				Model:           "gpt-4",
-				SummaryModel:    "gpt-4",
 			},
 			wantErr: true,
 		},
@@ -70,8 +62,6 @@ func TestConfig_Validate(t *testing.T) {
 				DocID:           "some-doc-id",
 				CredentialsPath: tmpDir,
 				ChunkSize:       1,
-				Model:           "gpt-4",
-				SummaryModel:    "gpt-4",
 			},
 			wantErr: true,
 		},
@@ -81,8 +71,6 @@ func TestConfig_Validate(t *testing.T) {
 				DocID:           "some-doc-id",
 				CredentialsPath: validCredsFile,
 				ChunkSize:       -1,
-				Model:           "gpt-4",
-				SummaryModel:    "gpt-4",
 			},
 			wantErr: true,
 		},
@@ -93,8 +81,6 @@ func TestConfig_Validate(t *testing.T) {
 				CredentialsPath: validCredsFile,
 				ChunkSize:       1,
 				OutputDir:       "bauer-output",
-				Model:           "gpt-5-mini-high",
-				SummaryModel:    "gpt-5-mini-high",
 			},
 			wantErr: false,
 		},
@@ -105,8 +91,6 @@ func TestConfig_Validate(t *testing.T) {
 				CredentialsPath: validCredsFile,
 				ChunkSize:       1,
 				OutputDir:       "bauer-output",
-				Model:           "",
-				SummaryModel:    "",
 			},
 			wantErr: false,
 		},
@@ -185,8 +169,6 @@ func TestChunkSizeDefaults(t *testing.T) {
 				ChunkSize:       effectiveChunkSize,
 				PageRefresh:     tt.pageRefreshFlag,
 				OutputDir:       "bauer-output",
-				Model:           "gpt-5-mini-high",
-				SummaryModel:    "gpt-5-mini-high",
 			}
 
 			// Validate should pass
diff --git a/internal/copilotcli/client.go b/internal/copilotcli/client.go
deleted file mode 100644
index beb30b5..0000000
--- a/internal/copilotcli/client.go
+++ /dev/null
@@ -1,380 +0,0 @@
-package copilotcli
-
-import (
-	"context"
-	"fmt"
-	"log/slog"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	copilot "github.com/github/copilot-sdk/go"
-)
-
-// ANSI color codes for terminal output
-const (
-	colorReset  = "\033[0m"
-	colorCyan   = "\033[36m"
-	colorYellow = "\033[33m"
-	colorDim    = "\033[2m"
-)
-
-// isTTY checks if stdout is a terminal (supports colors)
-func isTTY() bool {
-	fileInfo, _ := os.Stdout.Stat()
-	return (fileInfo.Mode() & os.ModeCharDevice) != 0
-}
-
-// formatCopilotOutput wraps text in color codes if terminal supports it
-func formatCopilotOutput(text string) string {
-	if isTTY() {
-		return colorCyan + text + colorReset
-	}
-	return text
-}
-
-// formatCopilotDim formats dimmed text for reasoning/debug output
-func formatCopilotDim(text string) string {
-	if isTTY() {
-		return colorDim + text + colorReset
-	}
-	return text
-}
-
-// formatSummaryOutput wraps text in yellow color for summary sessions
-func formatSummaryOutput(text string) string {
-	if isTTY() {
-		return colorYellow + text + colorReset
-	}
-	return text
-}
-
-// Client wraps the GitHub Copilot SDK client
-type Client struct {
-	client *copilot.Client
-	cwd    string
-}
-
-// NewClient creates and initializes a new Copilot client
-func NewClient(cwd string) (*Client, error) {
-	if cwd == "" {
-		var err error
-		cwd, err = os.Getwd()
-		if err != nil {
-			return nil, fmt.Errorf("failed to get working directory: %w", err)
-		}
-	}
-
-	// Create Copilot SDK client with default options
-	sdkClient := copilot.NewClient(&copilot.ClientOptions{
-		// CLIPath:  os.Getenv("COPILOT_CLI_PATH"), // Optional override
-		Cwd:      cwd,
-		LogLevel: "info", // TODO make configurable - set to error in production
-	})
-
-	return &Client{
-		client: sdkClient,
-		cwd:    cwd,
-	}, nil
-}
-
-// Start starts the Copilot CLI server
-func (c *Client) Start() error {
-	slog.Info("Starting Copilot client...")
-	if err := c.client.Start(); err != nil {
-		return fmt.Errorf("failed to start Copilot client: %w", err)
-	}
-
-	// Verify connectivity with ping
-	_, err := c.client.Ping("health-check")
-	if err != nil {
-		c.client.Stop()
-		return fmt.Errorf("Copilot client ping failed: %w", err)
-	}
-
-	slog.Info("Copilot client started successfully")
-	return nil
-}
-
-// Stop gracefully stops the Copilot CLI server
-func (c *Client) Stop() error {
-	slog.Info("Stopping Copilot client...")
-	errs := c.client.Stop()
-	if len(errs) > 0 {
-		for _, err := range errs {
-			slog.Error("Error during Copilot client shutdown", slog.String("error", err.Error()))
-		}
-		return fmt.Errorf("encountered %d errors during shutdown", len(errs))
-	}
-	slog.Info("Copilot client stopped successfully")
-	return nil
-}
-
-// ExecuteChunk processes a single chunk prompt using a Copilot session and returns the output
-func (c *Client) ExecuteChunk(ctx context.Context, chunkPath string, chunkNumber int, model string) (string, error) {
-	slog.Info("Creating Copilot session",
-		slog.Int("chunk", chunkNumber),
-		slog.String("model", model),
-	)
-
-	// Create a session with streaming enabled
-	session, err := c.client.CreateSession(&copilot.SessionConfig{
-		Model:     model,
-		Streaming: true,
-	})
-	if err != nil {
-		return "", fmt.Errorf("failed to create session for chunk %d: %w", chunkNumber, err)
-	}
-	defer func() {
-		if err := session.Destroy(); err != nil {
-			slog.Error("Failed to destroy session",
-				slog.Int("chunk", chunkNumber),
-				slog.String("error", err.Error()),
-			)
-		}
-	}()
-
-	// Set up event handler to stream output
-	done := make(chan error, 1)
-	var fullOutput string
-
-	session.On(func(event copilot.SessionEvent) {
-		switch event.Type {
-		// TODO these 2 events should be only for debugging/verbose logging
-		case "assistant.message_delta":
-			// Stream incremental content as it comes (in color)
-			if event.Data.DeltaContent != nil {
-				fmt.Print(formatCopilotOutput(*event.Data.DeltaContent))
-				fullOutput += *event.Data.DeltaContent
-			}
-
-		case "assistant.reasoning_delta":
-			// Stream reasoning content (dimmed)
-			if event.Data.DeltaContent != nil {
-				fmt.Print(formatCopilotDim(*event.Data.DeltaContent))
-				fullOutput += *event.Data.DeltaContent
-			}
-
-		case "assistant.message":
-			// Add to output and print the final message
-			if event.Data.Content != nil {
-				fullOutput += *event.Data.Content
-				fmt.Println(formatCopilotOutput(*event.Data.Content))
-				slog.Debug("Assistant response",
-					slog.Int("chunk", chunkNumber),
-					slog.String("content", *event.Data.Content),
-				)
-			}
-
-		case "assistant.reasoning":
-			// Add to output and print reasoning in dimmed style
-			if event.Data.Content != nil {
-				fullOutput += *event.Data.Content
-				fmt.Println(formatCopilotDim(*event.Data.Content))
-				slog.Debug("Assistant reasoning response",
-					slog.Int("chunk", chunkNumber),
-					slog.String("content", *event.Data.Content),
-				)
-			}
-
-		case "session.idle":
-			// Session completed successfully
-			slog.Info("Session completed",
-				slog.Int("chunk", chunkNumber),
-			)
-			done <- nil
-
-		case "session.error":
-			// Session encountered an error
-			errMsg := fmt.Sprintf("session error for chunk %d", chunkNumber)
-			if event.Data.Error != nil {
-				errMsg = fmt.Sprintf("%s: %v", errMsg, event.Data.Error)
-			}
-			slog.Error("Session error",
-				slog.Int("chunk", chunkNumber),
-				slog.String("error", errMsg),
-			)
-			done <- fmt.Errorf("%s", errMsg)
-
-		case "assistant.tool_call":
-			// Log tool calls for visibility
-			if event.Data.ToolName != nil {
-				slog.Debug("Tool called",
-					slog.Int("chunk", chunkNumber),
-					slog.String("tool", *event.Data.ToolName),
-				)
-			}
-		}
-	})
-
-	// Send the prompt with the chunk file as attachment
-	// Ensure the path is absolute for reliable access
-	absChunkPath, err := filepath.Abs(chunkPath)
-	if err != nil {
-		return "", fmt.Errorf("failed to resolve chunk path: %w", err)
-	}
-
-	slog.Info("Sending prompt to Copilot",
-		slog.Int("chunk", chunkNumber),
-		slog.String("file", absChunkPath),
-	)
-
-	_, err = session.Send(copilot.MessageOptions{
-		Prompt: fmt.Sprintf("Implement the changes described in @%s. Follow all instructions carefully and apply changes in order.", filepath.Base(chunkPath)),
-		Attachments: []copilot.Attachment{
-			{
-				Type:        copilot.File,
-				Path:        absChunkPath,
-				DisplayName: fmt.Sprintf("chunk-%d.md", chunkNumber),
-			},
-		},
-	})
-	if err != nil {
-		return "", fmt.Errorf("failed to send message for chunk %d: %w", chunkNumber, err)
-	}
-
-	// Wait for completion with timeout
-	select {
-	case err := <-done:
-		if err != nil {
-			return "", err
-		}
-		fmt.Println() // Add newline after streaming output
-		return fullOutput, nil
-
-	case <-time.After(15 * time.Minute):
-		return "", fmt.Errorf("chunk %d timed out after 15 minutes", chunkNumber)
-
-	case <-ctx.Done():
-		return "", fmt.Errorf("chunk %d cancelled: %w", chunkNumber, ctx.Err())
-	}
-}
-
-// ChunkOutput represents output from a chunk execution
-type ChunkOutput struct {
-	ChunkNumber int
-	Output      string
-	Duration    time.Duration
-}
-
-// GenerateSummary creates a summary session with all chunk outputs
-func (c *Client) GenerateSummary(ctx context.Context, outputs []ChunkOutput, model string) error {
-	slog.Info("Creating summary session", slog.String("model", model))
-
-	// Create a session with streaming enabled
-	session, err := c.client.CreateSession(&copilot.SessionConfig{
-		Model:     model,
-		Streaming: true,
-	})
-	if err != nil {
-		return fmt.Errorf("failed to create summary session: %w", err)
-	}
-	defer func() {
-		if err := session.Destroy(); err != nil {
-			slog.Error("Failed to destroy summary session", slog.String("error", err.Error()))
-		}
-	}()
-
-	// Set up event handler
-	done := make(chan error, 1)
-
-	session.On(func(event copilot.SessionEvent) {
-		switch event.Type {
-		case "assistant.message_delta":
-			if event.Data.DeltaContent != nil {
-				fmt.Print(formatSummaryOutput(*event.Data.DeltaContent))
-			}
-
-		case "assistant.reasoning_delta":
-			if event.Data.DeltaContent != nil {
-				fmt.Print(formatCopilotDim(*event.Data.DeltaContent))
-			}
-
-		case "assistant.message":
-			// Print final message in yellow for summary
-			if event.Data.Content != nil {
-				fmt.Println(formatSummaryOutput(*event.Data.Content))
-				slog.Debug("Summary response", slog.String("content", *event.Data.Content))
-			}
-
-		case "assistant.reasoning":
-			// Print reasoning in dimmed style
-			if event.Data.Content != nil {
-				fmt.Println(formatCopilotDim(*event.Data.Content))
-				slog.Debug("Summary reasoning", slog.String("content", *event.Data.Content))
-			}
-
-		case "session.idle":
-			slog.Info("Summary session completed")
-			done <- nil
-
-		case "session.error":
-			errMsg := "summary session error"
-			if event.Data.Error != nil {
-				errMsg = fmt.Sprintf("%s: %v", errMsg, event.Data.Error)
-			}
-			slog.Error("Summary session error", slog.String("error", errMsg))
-			done <- fmt.Errorf("%s", errMsg)
-		}
-	})
-
-	// Build summary prompt
-	summaryPrompt := buildSummaryPrompt(outputs)
-
-	slog.Info("Sending summary prompt to Copilot")
-
-	_, err = session.Send(copilot.MessageOptions{
-		Prompt: summaryPrompt,
-	})
-	if err != nil {
-		return fmt.Errorf("failed to send summary message: %w", err)
-	}
-
-	// Wait for completion
-	select {
-	case err := <-done:
-		if err != nil {
-			return err
-		}
-		fmt.Println() // Add newline after streaming output
-		return nil
-
-	case <-time.After(10 * time.Minute):
-		return fmt.Errorf("summary session timed out after 10 minutes")
-
-	case <-ctx.Done():
-		return fmt.Errorf("summary session cancelled: %w", ctx.Err())
-	}
-}
-
-// buildSummaryPrompt creates the prompt for the summary session
-func buildSummaryPrompt(outputs []ChunkOutput) string {
-	var prompt strings.Builder
-
-	prompt.WriteString("# Summary Task\n\n")
-	prompt.WriteString("You have just processed multiple chunks of changes for a web project using Vanilla Framework.\n")
-	prompt.WriteString("Please provide a comprehensive summary of all the work completed.\n\n")
-
-	prompt.WriteString("## Summary Requirements\n\n")
-	prompt.WriteString("Please provide:\n\n")
-	prompt.WriteString("1. **Overview**: Brief description of what was accomplished across all chunks\n")
-	prompt.WriteString("2. **Files Modified**: List of files that were created or modified\n")
-	prompt.WriteString("3. **Patterns Used**: Which Vanilla Framework patterns were implemented (Hero, Equal Heights, etc.)\n")
-	prompt.WriteString("4. **Key Changes**: Highlight significant changes or additions\n")
-	prompt.WriteString("5. **Potential Issues**: Any problems encountered or warnings to note\n")
-	prompt.WriteString("6. **Next Steps**: Recommended actions before creating a PR\n\n")
-	prompt.WriteString("Keep the summary concise but comprehensive. Focus on actionable information.\n\n")
-
-	prompt.WriteString("## Chunks Processed\n\n")
-
-	for _, output := range outputs {
-		fmt.Fprintf(&prompt, "### Chunk %d\n\n", output.ChunkNumber)
-		fmt.Fprintf(&prompt, "**Duration**: %s\n\n", output.Duration.Round(time.Millisecond))
-		prompt.WriteString("**Output**:\n```\n")
-		prompt.WriteString(output.Output)
-		prompt.WriteString("\n```\n\n")
-	}
-
-	return prompt.String()
-}
diff --git a/internal/gdocs/credentials.go b/internal/gdocs/credentials.go
index 1fa4fcc..ef74f33 100644
--- a/internal/gdocs/credentials.go
+++ b/internal/gdocs/credentials.go
@@ -8,14 +8,12 @@ import (
 
 // ServiceAccountCredentials represents the structure of a Google service account JSON key file.
 type ServiceAccountCredentials struct {
-	Type         string `json:"type"`
-	ProjectID    string `json:"project_id"`
-	PrivateKeyID string `json:"private_key_id"`
-	PrivateKey   string `json:"private_key"`
-	ClientEmail  string `json:"client_email"`
-	ClientID     string `json:"client_id"`
-	AuthURI      string `json:"auth_uri"`
-	TokenURI     string `json:"token_uri"`
+	Type        string `json:"type"`
+	ProjectID   string `json:"project_id"`
+	PrivateKey  string `json:"private_key"`
+	ClientEmail string `json:"client_email"`
+	AuthURI     string `json:"auth_uri"`
+	TokenURI    string `json:"token_uri"`
 }
 
 // ValidateCredentialsFile checks if the credentials file exists, is readable, and contains required fields.
diff --git a/internal/github/issue.go b/internal/github/issue.go
new file mode 100644
index 0000000..a6d5d2f
--- /dev/null
+++ b/internal/github/issue.go
@@ -0,0 +1,97 @@
+package github
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+// CreateIssueOptions holds options for creating an issue.
+type CreateIssueOptions struct {
+	Title     string
+	Body      string
+	Labels    []string
+	Assignees []string
+}
+
+// CreateIssue creates a GitHub issue using gh CLI.
+func CreateIssue(owner, repo string, opts CreateIssueOptions) (string, error) {
+	if opts.Title == "" {
+		return "", fmt.Errorf("issue title is required")
+	}
+
+	args := []string{
+		"issue", "create",
+		"--repo", fmt.Sprintf("%s/%s", owner, repo),
+		"--title", opts.Title,
+	}
+
+	if opts.Body != "" {
+		args = append(args, "--body", opts.Body)
+	}
+
+	for _, label := range opts.Labels {
+		args = append(args, "--label", label)
+	}
+
+	for _, assignee := range opts.Assignees {
+		args = append(args, "--assignee", assignee)
+	}
+
+	cmd := exec.Command("gh", args...)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", fmt.Errorf("failed to create issue: %w, output: %s", err, output)
+	}
+
+	outputStr := string(output)
+	lines := strings.Split(outputStr, "\n")
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "https://github.com/") {
+			return trimmed, nil
+		}
+	}
+
+	return "", fmt.Errorf("could not extract issue URL from output: %s", outputStr)
+}
+
+// AddIssueComment posts a comment to an existing issue.
+func AddIssueComment(owner, repo, issueNumber, body string) error {
+	if owner == "" || repo == "" || issueNumber == "" {
+		return fmt.Errorf("owner, repo, and issueNumber are required")
+	}
+	if strings.TrimSpace(body) == "" {
+		return fmt.Errorf("comment body cannot be empty")
+	}
+
+	cmd := exec.Command(
+		"gh", "issue", "comment", issueNumber,
+		"--repo", fmt.Sprintf("%s/%s", owner, repo),
+		"--body", body,
+	)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("failed to add issue comment: %w, output: %s", err, output)
+	}
+
+	return nil
+}
+
+// ExtractIssueNumberFromURL parses issue URL like
+// https://github.com/owner/repo/issues/123 and returns "123".
+func ExtractIssueNumberFromURL(issueURL string) (string, error) {
+	issueURL = strings.TrimSpace(issueURL)
+	if issueURL == "" {
+		return "", fmt.Errorf("issue URL is empty")
+	}
+	parts := strings.Split(issueURL, "/")
+	if len(parts) == 0 {
+		return "", fmt.Errorf("invalid issue URL: %s", issueURL)
+	}
+	n := parts[len(parts)-1]
+	if n == "" {
+		return "", fmt.Errorf("invalid issue URL: %s", issueURL)
+	}
+	return n, nil
+}
diff --git a/internal/github/remote_pr.go b/internal/github/remote_pr.go
new file mode 100644
index 0000000..018651f
--- /dev/null
+++ b/internal/github/remote_pr.go
@@ -0,0 +1,175 @@
+package github
+
+import (
+	"encoding/base64"
+	"fmt"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+// CreateParseResultPROptions configures remote PR creation from parse output.
+type CreateParseResultPROptions struct {
+	Owner        string
+	Repo         string
+	BranchPrefix string
+	BaseBranch   string
+	PRTitle      string
+	PRBody       string
+	FilePath     string
+	FileContent  []byte
+	CommitMsg    string
+}
+
+// CreateParseResultPR creates a branch, commits parse-result content, and opens a PR
+// directly against the target repository using gh API (no local clone required).
+func CreateParseResultPR(opts CreateParseResultPROptions) (prURL string, branchName string, err error) {
+	if opts.Owner == "" || opts.Repo == "" {
+		return "", "", fmt.Errorf("owner and repo are required")
+	}
+	if len(opts.FileContent) == 0 {
+		return "", "", fmt.Errorf("file content cannot be empty")
+	}
+	if opts.FilePath == "" {
+		opts.FilePath = "bauer-output/bauer-parse-result.json"
+	}
+	if opts.CommitMsg == "" {
+		opts.CommitMsg = "Add bauer parse result"
+	}
+
+	if opts.BaseBranch == "" {
+		defaultBranch, getErr := GetDefaultBranchRemote(opts.Owner, opts.Repo)
+		if getErr != nil {
+			return "", "", fmt.Errorf("failed to resolve base branch: %w", getErr)
+		}
+		opts.BaseBranch = defaultBranch
+	}
+
+	if opts.BranchPrefix == "" {
+		opts.BranchPrefix = "bauer"
+	}
+
+	branchName = fmt.Sprintf("%s/parse-result-%d", opts.BranchPrefix, time.Now().Unix())
+
+	baseSHA, err := getBranchHeadSHA(opts.Owner, opts.Repo, opts.BaseBranch)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to read base branch sha: %w", err)
+	}
+
+	if err := createBranchRef(opts.Owner, opts.Repo, branchName, baseSHA); err != nil {
+		return "", "", fmt.Errorf("failed to create remote branch: %w", err)
+	}
+
+	encodedContent := base64.StdEncoding.EncodeToString(opts.FileContent)
+	if err := putFileOnBranch(opts.Owner, opts.Repo, branchName, opts.FilePath, opts.CommitMsg, encodedContent); err != nil {
+		return "", "", fmt.Errorf("failed to commit parse result file: %w", err)
+	}
+
+	prOpts := CreatePROptions{
+		Title:      opts.PRTitle,
+		Body:       opts.PRBody,
+		HeadBranch: branchName,
+		BaseBranch: opts.BaseBranch,
+	}
+
+	prURL, err = CreatePR(opts.Owner, opts.Repo, prOpts)
+	if err != nil {
+		return "", branchName, fmt.Errorf("failed to create PR: %w", err)
+	}
+
+	return prURL, branchName, nil
+}
+
+// GetDefaultBranchRemote resolves the default branch for a repository via gh api.
+func GetDefaultBranchRemote(owner, repo string) (string, error) {
+	cmd := exec.Command("gh", "api", fmt.Sprintf("repos/%s/%s", owner, repo), "--jq", ".default_branch")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", fmt.Errorf("gh api failed: %w, output: %s", err, output)
+	}
+	branch := strings.TrimSpace(string(output))
+	if branch == "" {
+		return "", fmt.Errorf("empty default branch response")
+	}
+	return branch, nil
+}
+
+func getBranchHeadSHA(owner, repo, branch string) (string, error) {
+	cmd := exec.Command(
+		"gh", "api",
+		fmt.Sprintf("repos/%s/%s/git/ref/heads/%s", owner, repo, branch),
+		"--jq", ".object.sha",
+	)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", fmt.Errorf("gh api failed: %w, output: %s", err, output)
+	}
+	sha := strings.TrimSpace(string(output))
+	if sha == "" {
+		return "", fmt.Errorf("empty sha response for branch %s", branch)
+	}
+	return sha, nil
+}
+
+func createBranchRef(owner, repo, branchName, sha string) error {
+	cmd := exec.Command(
+		"gh", "api", "-X", "POST",
+		fmt.Sprintf("repos/%s/%s/git/refs", owner, repo),
+		"-f", "ref=refs/heads/"+branchName,
+		"-f", "sha="+sha,
+	)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("gh api failed: %w, output: %s", err, output)
+	}
+	return nil
+}
+
+func putFileOnBranch(owner, repo, branch, path, message, encodedContent string) error {
+	existingSHA, err := getFileSHAOnBranch(owner, repo, branch, path)
+	if err != nil {
+		return fmt.Errorf("failed to resolve existing file sha: %w", err)
+	}
+
+	args := []string{
+		"api", "-X", "PUT",
+		fmt.Sprintf("repos/%s/%s/contents/%s", owner, repo, path),
+		"-f", "message=" + message,
+		"-f", "content=" + encodedContent,
+		"-f", "branch=" + branch,
+	}
+	if existingSHA != "" {
+		args = append(args, "-f", "sha="+existingSHA)
+	}
+
+	cmd := exec.Command("gh", args...)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("gh api failed: %w, output: %s", err, output)
+	}
+	return nil
+}
+
+func getFileSHAOnBranch(owner, repo, branch, path string) (string, error) {
+	cmd := exec.Command(
+		"gh", "api",
+		fmt.Sprintf("repos/%s/%s/contents/%s", owner, repo, path),
+		"-f", "ref="+branch,
+		"--jq", ".sha",
+	)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		// File doesn't exist on this branch yet; PUT must omit sha in this case.
+		if strings.Contains(string(output), "404") {
+			return "", nil
+		}
+		return "", fmt.Errorf("gh api failed: %w, output: %s", err, output)
+	}
+
+	sha := strings.TrimSpace(string(output))
+	if sha == "" {
+		return "", nil
+	}
+
+	return sha, nil
+}
diff --git a/internal/github/repo.go b/internal/github/repo.go
index 660cb75..002d0f7 100644
--- a/internal/github/repo.go
+++ b/internal/github/repo.go
@@ -199,6 +199,50 @@ func CommitChanges(localPath, message string) error {
 	return nil
 }
 
+// CommitFiles stages only the provided files and commits them with a message.
+func CommitFiles(localPath, message string, files []string) error {
+	if len(files) == 0 {
+		return fmt.Errorf("no files provided to commit")
+	}
+
+	args := []string{"add", "--"}
+	args = append(args, files...)
+	cmd := exec.Command("git", args...)
+	cmd.Dir = localPath
+	if output, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("failed to stage files: %w, output: %s", err, output)
+	}
+
+	cmd = exec.Command("git", "diff", "--cached", "--name-only")
+	cmd.Dir = localPath
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("failed to inspect staged files: %w, output: %s", err, output)
+	}
+	if strings.TrimSpace(string(output)) == "" {
+		return fmt.Errorf("no staged changes to commit")
+	}
+
+	cmd = exec.Command("git", "commit", "-m", message)
+	cmd.Dir = localPath
+	if output, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("failed to commit files: %w, output: %s", err, output)
+	}
+
+	return nil
+}
+
+// GetHeadCommitSHA returns the SHA of HEAD in the given repository.
+func GetHeadCommitSHA(localPath string) (string, error) {
+	cmd := exec.Command("git", "rev-parse", "HEAD")
+	cmd.Dir = localPath
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", fmt.Errorf("failed to read HEAD commit SHA: %w, output: %s", err, output)
+	}
+	return strings.TrimSpace(string(output)), nil
+}
+
 // PushBranch pushes the specified branch to remote
 func PushBranch(localPath, branchName string) error {
 	cmd := exec.Command("git", "push", "origin", branchName)
diff --git a/internal/orchestrator/orchestrator.go b/internal/orchestrator/orchestrator.go
index efc8143..fc9df0d 100644
--- a/internal/orchestrator/orchestrator.go
+++ b/internal/orchestrator/orchestrator.go
@@ -2,7 +2,6 @@ package orchestrator
 
 import (
 	"bauer/internal/config"
-	"bauer/internal/copilotcli"
 	"bauer/internal/gdocs"
 	"bauer/internal/prompt"
 	"context"
@@ -26,14 +25,9 @@ type OrchestrationResult struct {
 	Chunks       []prompt.ChunkResult
 	PlanDuration time.Duration
 
-	// Only populated if not dry run
-	CopilotOutputs  []copilotcli.ChunkOutput
-	CopilotDuration time.Duration
-	SummaryDuration time.Duration
-
 	// Metadata
 	TotalDuration time.Duration
-	DryRun        bool
+	ParseOnly     bool
 }
 
 // Orchestrator defines the interface for executing the BAU orchestration flow.
@@ -49,7 +43,7 @@ func NewOrchestrator() *DefaultOrchestrator {
 	return &DefaultOrchestrator{}
 }
 
-// Execute runs the full pipeline: extraction, prompt generation, and optional Copilot execution.
+// Execute runs the full pipeline: extraction, prompt generation, and optional GitHub integration.
 // Accepts: Config and Context
 // Returns: OrchestrationResult and error
 func (o *DefaultOrchestrator) Execute(ctx context.Context, cfg *config.Config) (*OrchestrationResult, error) {
@@ -127,11 +121,8 @@ func (o *DefaultOrchestrator) Execute(ctx context.Context, cfg *config.Config) (
 			ParseResult:        parseResult,
 			Chunks:             []prompt.ChunkResult{},
 			PlanDuration:       0,
-			CopilotOutputs:     []copilotcli.ChunkOutput{},
-			CopilotDuration:    0,
-			SummaryDuration:    0,
 			TotalDuration:      totalDuration,
-			DryRun:             false,
+			ParseOnly:          cfg.ParseOnly,
 		}, nil
 	}
 
@@ -169,80 +160,6 @@ func (o *DefaultOrchestrator) Execute(ctx context.Context, cfg *config.Config) (
 		)
 	}
 
-	// If dry run, return early
-	if cfg.DryRun {
-		totalDuration := time.Since(startTime)
-
-		return &OrchestrationResult{
-			ExtractionResult:   result,
-			ExtractionDuration: extractionDuration,
-			Chunks:             chunks,
-			PlanDuration:       planDuration,
-			CopilotOutputs:     []copilotcli.ChunkOutput{},
-			CopilotDuration:    0,
-			SummaryDuration:    0,
-			TotalDuration:      totalDuration,
-			DryRun:             true,
-		}, nil
-	}
-
-	// 6. Execute via Copilot SDK
-	cwd, err := os.Getwd()
-	if err != nil {
-		slog.Error("Failed to get working directory", slog.String("error", err.Error()))
-		return nil, fmt.Errorf("failed to get working directory: %w", err)
-	}
-
-	slog.Info("Initializing Copilot client", slog.String("cwd", cwd))
-	copilotClient, err := copilotcli.NewClient(cwd)
-	if err != nil {
-		slog.Error("Failed to create Copilot client", slog.String("error", err.Error()))
-		return nil, fmt.Errorf("failed to create Copilot client: %w", err)
-	}
-
-	// Start the Copilot CLI server once
-	if err := copilotClient.Start(); err != nil {
-		// Attempt to stop the client if Start failed
-		if stopErr := copilotClient.Stop(); stopErr != nil {
-			slog.Error("Failed to stop Copilot client after start failure", slog.String("error", stopErr.Error()))
-		}
-		slog.Error("Failed to start Copilot", slog.String("error", err.Error()))
-		return nil, fmt.Errorf("failed to start Copilot: %w", err)
-	}
-	defer func() {
-		if err := copilotClient.Stop(); err != nil {
-			slog.Error("Failed to stop Copilot client", slog.String("error", err.Error()))
-		}
-	}()
-
-	// Execute chunks via Copilot SDK
-	chunkOutputs, copilotDuration, err := executeCopilotChunks(ctx, chunks, cfg, copilotClient)
-	if err != nil {
-		slog.Error("Copilot execution failed", slog.String("error", err.Error()))
-		return nil, fmt.Errorf("copilot execution failed: %w", err)
-	}
-
-	slog.Info("Copilot chunks executed",
-		slog.Int("chunk_count", len(chunks)),
-		slog.Duration("total_duration", copilotDuration),
-	)
-
-	// 7. Generate summary if multiple chunks
-	summaryDuration := time.Duration(0)
-	if len(chunks) > 1 {
-		summaryStart := time.Now()
-
-		if err := copilotClient.GenerateSummary(ctx, chunkOutputs, cfg.SummaryModel); err != nil {
-			slog.Error("Summary generation failed", slog.String("error", err.Error()))
-			// Summary failure is not fatal; continue with results
-		} else {
-			summaryDuration = time.Since(summaryStart)
-			slog.Info("Summary generated successfully",
-				slog.Duration("duration", summaryDuration),
-			)
-		}
-	}
-
 	totalDuration := time.Since(startTime)
 
 	return &OrchestrationResult{
@@ -250,57 +167,7 @@ func (o *DefaultOrchestrator) Execute(ctx context.Context, cfg *config.Config) (
 		ExtractionDuration: extractionDuration,
 		Chunks:             chunks,
 		PlanDuration:       planDuration,
-		CopilotOutputs:     chunkOutputs,
-		CopilotDuration:    copilotDuration,
-		SummaryDuration:    summaryDuration,
 		TotalDuration:      totalDuration,
-		DryRun:             false,
+		ParseOnly:          false,
 	}, nil
 }
-
-// executeCopilotChunks executes each chunk via the Copilot SDK and returns outputs
-func executeCopilotChunks(
-	ctx context.Context,
-	chunks []prompt.ChunkResult,
-	cfg *config.Config,
-	client *copilotcli.Client,
-) ([]copilotcli.ChunkOutput, time.Duration, error) {
-	executionStart := time.Now()
-
-	var outputs []copilotcli.ChunkOutput
-	totalChunks := len(chunks)
-
-	for i, chunk := range chunks {
-		chunkStart := time.Now()
-
-		slog.Info("Executing chunk",
-			slog.Int("chunk_number", chunk.ChunkNumber),
-			slog.Int("chunk_count", totalChunks),
-		)
-
-		// Execute the chunk
-		output, err := client.ExecuteChunk(ctx, chunk.Filename, chunk.ChunkNumber, cfg.Model)
-		if err != nil {
-			return nil, 0, fmt.Errorf("failed to execute chunk %d: %w", chunk.ChunkNumber, err)
-		}
-
-		chunkDuration := time.Since(chunkStart)
-
-		// Collect output
-		outputs = append(outputs, copilotcli.ChunkOutput{
-			ChunkNumber: chunk.ChunkNumber,
-			Output:      output,
-			Duration:    chunkDuration,
-		})
-
-		slog.Info("Chunk executed successfully",
-			slog.Int("chunk", chunk.ChunkNumber),
-			slog.Int("completed", i+1),
-			slog.Int("total", totalChunks),
-			slog.Duration("duration", chunkDuration),
-		)
-	}
-
-	totalDuration := time.Since(executionStart)
-	return outputs, totalDuration, nil
-}
diff --git a/internal/prompt/README.md b/internal/prompt/README.md
index fa35740..98a1928 100644
--- a/internal/prompt/README.md
+++ b/internal/prompt/README.md
@@ -98,10 +98,11 @@ Templates in `templates/`:
    - Hero, Equal Heights, Text Spotlight, etc.
    - Usage examples and parameters
 
-4. **`pr-description.md`**: PR body template
+4. **`pr-description.md`**: Shared issue/PR body template
     - References instruction/pattern templates
     - Lists generated chunk files
     - Includes suggestion and change-type summary for Copilot execution
+    - Used as the base for issue descriptions in parse-and-issue workflow mode
 
 
 ## String Replacement
diff --git a/internal/prompt/pr_description.go b/internal/prompt/pr_description.go
new file mode 100644
index 0000000..2b646d2
--- /dev/null
+++ b/internal/prompt/pr_description.go
@@ -0,0 +1,129 @@
+package prompt
+
+import (
+	_ "embed"
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"bauer/internal/gdocs"
+)
+
+//go:embed templates/pr-description.md
+var prDescriptionTemplate string
+
+// BuildPRDescription renders a PR description that references the prompt templates
+// and summarizes extracted suggestions for Copilot execution.
+func BuildPRDescription(result *gdocs.ProcessingResult, chunks []ChunkResult, usePageRefresh bool) string {
+	if result == nil {
+		return "# @copilot Apply BAU Suggestions\n\nNo extraction result was available."
+	}
+
+	instructionsTemplatePath := "internal/prompt/templates/copy-docs-instructions.md"
+	mode := "copy-docs"
+	if usePageRefresh {
+		instructionsTemplatePath = "internal/prompt/templates/page-refresh-instructions.md"
+		mode = "page-refresh"
+	}
+
+	suggestedURL := ""
+	if result.Metadata != nil {
+		suggestedURL = result.Metadata.SuggestedUrl
+	}
+
+	insertCount, deleteCount, replaceCount := summarizeSuggestionTypes(result.ActionableSuggestions)
+
+	chunkList := "- No chunk files were generated."
+	if len(chunks) > 0 {
+		var lines []string
+		for _, chunk := range chunks {
+			chunkFile := filepath.ToSlash(chunk.Filename)
+			lines = append(lines, fmt.Sprintf("- `%s`", chunkFile))
+		}
+		chunkList = strings.Join(lines, "\n")
+	}
+
+	body := prDescriptionTemplate
+	body = replaceVar(body, "DocumentTitle", result.DocumentTitle)
+	body = replaceVar(body, "DocumentID", result.DocumentID)
+	body = replaceVar(body, "SuggestedURL", suggestedURL)
+	body = replaceVar(body, "Mode", mode)
+	body = replaceVar(body, "InstructionsTemplatePath", instructionsTemplatePath)
+	body = replaceVar(body, "PatternsTemplatePath", "internal/prompt/templates/vanilla-patterns.md")
+	body = replaceVar(body, "ChunkFiles", chunkList)
+	body = replaceVar(body, "LocationCount", fmt.Sprintf("%d", len(result.GroupedSuggestions)))
+	body = replaceVar(body, "SuggestionCount", fmt.Sprintf("%d", len(result.ActionableSuggestions)))
+	body = replaceVar(body, "InsertCount", fmt.Sprintf("%d", insertCount))
+	body = replaceVar(body, "DeleteCount", fmt.Sprintf("%d", deleteCount))
+	body = replaceVar(body, "ReplaceCount", fmt.Sprintf("%d", replaceCount))
+
+	return body
+}
+
+// BuildIssueDescription renders an issue description for Copilot.
+// The full parse JSON is linked in the "Prompt Source" section appended by the workflow.
+func BuildIssueDescription(result *gdocs.ProcessingResult, chunks []ChunkResult, usePageRefresh bool) string {
+	body := BuildPRDescription(result, chunks, usePageRefresh)
+
+	var b strings.Builder
+	b.WriteString(body)
+	b.WriteString("\n\n## Parsed Output (Machine Readable)\n\n")
+	b.WriteString("The full parse JSON is available via the branch-backed prompt file links in the \"Prompt Source\" section below.\n")
+
+	return b.String()
+}
+
+// BuildIssueJSONComments splits parse JSON into comment-safe chunks.
+func BuildIssueJSONComments(parseResultJSON string) []string {
+	const maxJSONPerComment = 45000
+	if parseResultJSON == "" {
+		return []string{}
+	}
+
+	parts := splitByLimit(parseResultJSON, maxJSONPerComment)
+	comments := make([]string, 0, len(parts))
+	for i, part := range parts {
+		comments = append(comments,
+			fmt.Sprintf("### Parsed Output Part %d/%d\n\n```json\n%s\n```", i+1, len(parts), part),
+		)
+	}
+
+	return comments
+}
+
+func splitByLimit(s string, max int) []string {
+	if len(s) <= max {
+		return []string{s}
+	}
+
+	parts := []string{}
+	for len(s) > 0 {
+		if len(s) <= max {
+			parts = append(parts, s)
+			break
+		}
+
+		cut := max
+		if idx := strings.LastIndex(s[:max], "\n"); idx > 0 {
+			cut = idx
+		}
+		parts = append(parts, s[:cut])
+		s = s[cut:]
+	}
+
+	return parts
+}
+
+func summarizeSuggestionTypes(suggestions []gdocs.ActionableSuggestion) (insertCount, deleteCount, replaceCount int) {
+	for _, s := range suggestions {
+		switch s.Change.Type {
+		case "insert":
+			insertCount++
+		case "delete":
+			deleteCount++
+		case "replace":
+			replaceCount++
+		}
+	}
+	return insertCount, deleteCount, replaceCount
+}
diff --git a/internal/prompt/pr_description_test.go b/internal/prompt/pr_description_test.go
new file mode 100644
index 0000000..64ee9b0
--- /dev/null
+++ b/internal/prompt/pr_description_test.go
@@ -0,0 +1,56 @@
+package prompt
+
+import (
+	"testing"
+
+	"bauer/internal/gdocs"
+)
+
+func TestBuildPRDescription_IncludesTemplateReferences(t *testing.T) {
+	result := &gdocs.ProcessingResult{
+		DocumentTitle: "Copy of example.com/page",
+		DocumentID:    "doc-123",
+		Metadata: &gdocs.MetadataTable{
+			SuggestedUrl: "example.com/page",
+		},
+		GroupedSuggestions: []gdocs.LocationGroupedSuggestions{
+			{},
+			{},
+		},
+		ActionableSuggestions: []gdocs.ActionableSuggestion{
+			{Change: gdocs.SuggestionChange{Type: "insert"}},
+			{Change: gdocs.SuggestionChange{Type: "delete"}},
+			{Change: gdocs.SuggestionChange{Type: "replace"}},
+		},
+	}
+
+	chunks := []ChunkResult{{Filename: "bauer-output/chunk-1-of-1.md"}}
+	body := BuildPRDescription(result, chunks, false)
+
+	expected := []string{
+		"@copilot",
+		"internal/prompt/templates/copy-docs-instructions.md",
+		"internal/prompt/templates/vanilla-patterns.md",
+		"`bauer-output/chunk-1-of-1.md`",
+		"Grouped locations: 2",
+		"Atomic actionable suggestions: 3",
+	}
+
+	for _, e := range expected {
+		if !contains(body, e) {
+			t.Fatalf("expected PR description to contain %q", e)
+		}
+	}
+}
+
+func TestBuildPRDescription_PageRefreshTemplateReference(t *testing.T) {
+	result := &gdocs.ProcessingResult{
+		DocumentTitle: "Doc",
+		DocumentID:    "doc-abc",
+	}
+
+	body := BuildPRDescription(result, nil, true)
+	if !contains(body, "internal/prompt/templates/page-refresh-instructions.md") {
+		t.Fatalf("expected page refresh template reference in PR description")
+	}
+}
diff --git a/internal/workflow/api.go b/internal/workflow/api.go
index 891eb6b..cf33bd8 100644
--- a/internal/workflow/api.go
+++ b/internal/workflow/api.go
@@ -13,9 +13,9 @@ import (
 // APIRequest represents the API request for executing a workflow
 type APIRequest struct {
 	// GitHub configuration
-	GitHubRepo   string `json:"github_repo" binding:"required"`  // "owner/repo" or HTTPS URL
-	GitHubToken  string `json:"github_token" binding:"required"` // Personal access token
-	BranchPrefix string `json:"branch_prefix" default:"bauer"`   // Branch naming prefix
+	GitHubRepo   string `json:"github_repo"`                   // "owner/repo" or HTTPS URL (optional; required if not parse_only)
+	GitHubToken  string `json:"github_token"`                  // Personal access token (optional; required if not parse_only)
+	BranchPrefix string `json:"branch_prefix" default:"bauer"` // Branch naming prefix
 
 	// Bauer configuration
 	DocID       string `json:"doc_id" binding:"required"`         // Google Doc ID
@@ -23,8 +23,7 @@ type APIRequest struct {
 	ChunkSize   int    `json:"chunk_size" default:"1"`            // Number of chunks
 	PageRefresh bool   `json:"page_refresh" default:"false"`      // Page refresh mode
 	OutputDir   string `json:"output_dir" default:"bauer-output"` // Output directory
-	Model       string `json:"model" default:"gpt-5-mini-high"`   // Copilot model
-	DryRun      bool   `json:"dry_run" default:"false"`           // Dry run mode
+	ParseOnly   bool   `json:"parse_only" default:"false"`        // Parse-only mode
 
 	// Local repository path
 	LocalRepoPath string `json:"local_repo_path" default:"/tmp"` // Where to clone (optional)
@@ -58,12 +57,13 @@ func ExecuteWorkflowHandler(orch orchestrator.Orchestrator) http.HandlerFunc {
 		}
 
 		// Validate request
-		if req.GitHubRepo == "" {
-			writeError(w, http.StatusBadRequest, "github_repo is required")
+		// github_repo and github_token are required only when NOT in parse-only mode
+		if !req.ParseOnly && req.GitHubRepo == "" {
+			writeError(w, http.StatusBadRequest, "github_repo is required (unless parse_only=true)")
 			return
 		}
-		if req.GitHubToken == "" {
-			writeError(w, http.StatusBadRequest, "github_token is required")
+		if !req.ParseOnly && req.GitHubToken == "" {
+			writeError(w, http.StatusBadRequest, "github_token is required (unless parse_only=true)")
 			return
 		}
 		if req.DocID == "" {
@@ -74,7 +74,6 @@ func ExecuteWorkflowHandler(orch orchestrator.Orchestrator) http.HandlerFunc {
 			writeError(w, http.StatusBadRequest, "credentials is required")
 			return
 		}
-
 		// Set defaults
 		if req.BranchPrefix == "" {
 			req.BranchPrefix = "bauer"
@@ -85,9 +84,6 @@ func ExecuteWorkflowHandler(orch orchestrator.Orchestrator) http.HandlerFunc {
 		if req.OutputDir == "" {
 			req.OutputDir = "bauer-output"
 		}
-		if req.Model == "" {
-			req.Model = "gpt-5-mini-high"
-		}
 		if req.ChunkSize == 0 {
 			req.ChunkSize = 1
 		}
@@ -102,15 +98,15 @@ func ExecuteWorkflowHandler(orch orchestrator.Orchestrator) http.HandlerFunc {
 			ChunkSize:     req.ChunkSize,
 			PageRefresh:   req.PageRefresh,
 			OutputDir:     req.OutputDir,
-			Model:         req.Model,
-			DryRun:        req.DryRun,
+			ParseOnly:     req.ParseOnly,
 			LocalRepoPath: fmt.Sprintf("%s/%s-%d", req.LocalRepoPath, "bauer-workflow", time.Now().Unix()),
 		}
 
 		logger.Info("workflow API request",
 			"github_repo", req.GitHubRepo,
 			"doc_id", req.DocID,
-			"dry_run", req.DryRun,
+			"parse_only", req.ParseOnly,
+			"mode", map[bool]string{true: "parse-only", false: "parse-and-issue"}[req.ParseOnly],
 		)
 
 		// Execute workflow
@@ -128,10 +124,17 @@ func ExecuteWorkflowHandler(orch orchestrator.Orchestrator) http.HandlerFunc {
 
 			switch workflowOutput.Status {
 			case "success":
-				response.Message = fmt.Sprintf(
-					"Workflow completed successfully. PR: %s",
-					workflowOutput.FinalizationInfo.PullRequest.URL,
-				)
+				if workflowOutput.FinalizationInfo.Issue.URL != "" {
+					response.Message = fmt.Sprintf(
+						"Workflow completed successfully. Issue: %s",
+						workflowOutput.FinalizationInfo.Issue.URL,
+					)
+				} else {
+					response.Message = fmt.Sprintf(
+						"Workflow completed successfully. Output file: %s",
+						workflowOutput.OutputFile,
+					)
+				}
 			case "partial":
 				response.Message = fmt.Sprintf(
 					"Workflow completed with errors. Branch: %s. Errors: %d",
diff --git a/internal/workflow/workflow.go b/internal/workflow/workflow.go
index cd82e4b..dd929d2 100644
--- a/internal/workflow/workflow.go
+++ b/internal/workflow/workflow.go
@@ -12,6 +12,7 @@ import (
 	"bauer/internal/config"
 	"bauer/internal/github"
 	"bauer/internal/orchestrator"
+	"bauer/internal/prompt"
 )
 
 // WorkflowInput represents the input for a complete workflow execution
@@ -27,9 +28,7 @@ type WorkflowInput struct {
 	ChunkSize   int
 	PageRefresh bool
 	OutputDir   string
-	Model       string
-	DryRun      bool
-	ParseOnly   bool // Phase 1: Parse document only, skip GitHub integration
+	ParseOnly   bool // Parse document to JSON only.
 
 	// Local repository path
 	LocalRepoPath string
@@ -51,7 +50,6 @@ type WorkflowOutput struct {
 	BauerResult struct {
 		ExtractionDuration time.Duration `json:"extraction_duration"`
 		PlanDuration       time.Duration `json:"plan_duration"`
-		CopilotDuration    time.Duration `json:"copilot_duration"`
 		ChunkCount         int           `json:"chunk_count"`
 		TotalSuggestions   int           `json:"total_suggestions"`
 	} `json:"bauer_result"`
@@ -60,7 +58,11 @@ type WorkflowOutput struct {
 	FinalizationInfo struct {
 		CommitMessage string
 		BranchPushed  bool
-		PullRequest   struct {
+		Issue         struct {
+			URL   string
+			Title string
+		}
+		PullRequest struct {
 			URL    string
 			Number int
 			Title  string
@@ -79,12 +81,9 @@ type WorkflowOutput struct {
 	Warnings      []string      `json:"warnings"`
 }
 
-// ExecuteWorkflow orchestrates the complete flow:
-// 1. GitHub Setup (clone, create branch)
-// 2. Bauer Processing (extract, chunk, apply changes)
-// 3. GitHub Finalization (commit, push, create PR)
-//
-// If ParseOnly is true, skips steps 1 and 3, outputs parsed data to JSON
+// ExecuteWorkflow orchestrates a parse-first flow:
+// 1. Parse Google Doc and write bauer-parse-result.json
+// 2. If ParseOnly is false, push the JSON to a branch and create a Copilot issue
 func ExecuteWorkflow(ctx context.Context, input WorkflowInput, orch orchestrator.Orchestrator) (*WorkflowOutput, error) {
 	output := &WorkflowOutput{
 		Status:    "pending",
@@ -111,266 +110,281 @@ func ExecuteWorkflow(ctx context.Context, input WorkflowInput, orch orchestrator
 		logger.Info("workflow: resolved credentials path", "path", credentialsPath)
 	}
 
-	// PHASE 1: Parse-only mode - extract and output JSON without GitHub integration
-	if input.ParseOnly {
-		logger.Info("workflow: Phase 1 - Parse-only mode")
-
-		// Create Bauer config for parsing
-		bauerCfg := &config.Config{
-			DocID:           input.DocID,
-			CredentialsPath: credentialsPath,
-			DryRun:          true, // Always dry-run in parse-only mode
-			ChunkSize:       input.ChunkSize,
-			PageRefresh:     input.PageRefresh,
-			OutputDir:       input.OutputDir,
-			Model:           input.Model,
-			TargetRepo:      ".", // Current directory (doesn't matter for parse-only)
-			ParseOnly:       true,
-		}
+	logger.Info("workflow: parse phase")
 
-		bauerCfg.ApplyDefaults()
-		input.OutputDir = bauerCfg.OutputDir
-		input.Model = bauerCfg.Model
+	bauerCfg := &config.Config{
+		DocID:           input.DocID,
+		CredentialsPath: credentialsPath,
+		ChunkSize:       input.ChunkSize,
+		PageRefresh:     input.PageRefresh,
+		OutputDir:       input.OutputDir,
+		TargetRepo:      ".",
+		ParseOnly:       true,
+	}
 
-		logger.Info("workflow: Executing parse-only orchestration")
+	bauerCfg.ApplyDefaults()
+	input.OutputDir = bauerCfg.OutputDir
 
-		// Execute parse-only orchestration
-		bauerResult, err := orch.Execute(ctx, bauerCfg)
-		if err != nil {
-			output.Status = "failed"
-			output.Errors = append(output.Errors, fmt.Sprintf("Bauer parsing error: %v", err))
-			output.EndTime = time.Now()
-			output.TotalDuration = output.EndTime.Sub(output.StartTime)
-			return output, err
-		}
+	bauerResult, err := orch.Execute(ctx, bauerCfg)
+	if err != nil {
+		output.Status = "failed"
+		output.Errors = append(output.Errors, fmt.Sprintf("Bauer parsing error: %v", err))
+		output.EndTime = time.Now()
+		output.TotalDuration = output.EndTime.Sub(output.StartTime)
+		return output, err
+	}
 
-		// Store results from orchestrator
-		if bauerResult != nil {
-			output.BauerResult.ExtractionDuration = bauerResult.ExtractionDuration
-			output.BauerResult.PlanDuration = 0    // No prompt generation in parse-only mode
-			output.BauerResult.CopilotDuration = 0 // No Copilot execution in parse-only mode
-			if bauerResult.ParseResult != nil {
-				output.BauerResult.TotalSuggestions = len(bauerResult.ParseResult.ActionableSuggestions)
-			}
+	if bauerResult != nil {
+		output.BauerResult.ExtractionDuration = bauerResult.ExtractionDuration
+		output.BauerResult.PlanDuration = 0
+		if bauerResult.ParseResult != nil {
+			output.BauerResult.TotalSuggestions = len(bauerResult.ParseResult.ActionableSuggestions)
 		}
+	}
 
-		// Write the simplified ParseResult to JSON file
-		absOutputDir, err := filepath.Abs(input.OutputDir)
+	absOutputDir, err := filepath.Abs(input.OutputDir)
+	if err != nil {
+		output.Status = "failed"
+		output.Errors = append(output.Errors, fmt.Sprintf("failed to resolve output directory path: %v", err))
+		output.EndTime = time.Now()
+		output.TotalDuration = output.EndTime.Sub(output.StartTime)
+		return output, err
+	}
+
+	if err := os.MkdirAll(absOutputDir, 0755); err != nil {
+		output.Status = "failed"
+		output.Errors = append(output.Errors, fmt.Sprintf("failed to create output directory: %v", err))
+		output.EndTime = time.Now()
+		output.TotalDuration = output.EndTime.Sub(output.StartTime)
+		return output, err
+	}
+
+	outputPath := filepath.Join(absOutputDir, "bauer-parse-result.json")
+	if bauerResult != nil && bauerResult.ParseResult != nil {
+		parseResultJSON, err := json.MarshalIndent(bauerResult.ParseResult, "", "  ")
 		if err != nil {
 			output.Status = "failed"
-			output.Errors = append(output.Errors, fmt.Sprintf("failed to resolve output directory path: %v", err))
+			output.Errors = append(output.Errors, fmt.Sprintf("failed to marshal parse result: %v", err))
 			output.EndTime = time.Now()
 			output.TotalDuration = output.EndTime.Sub(output.StartTime)
 			return output, err
 		}
 
-		if err := os.MkdirAll(absOutputDir, 0755); err != nil {
+		if err := os.WriteFile(outputPath, parseResultJSON, 0644); err != nil {
 			output.Status = "failed"
-			output.Errors = append(output.Errors, fmt.Sprintf("failed to create output directory: %v", err))
+			output.Errors = append(output.Errors, fmt.Sprintf("failed to write parse result file: %v", err))
 			output.EndTime = time.Now()
 			output.TotalDuration = output.EndTime.Sub(output.StartTime)
 			return output, err
 		}
+	}
 
-		outputPath := filepath.Join(absOutputDir, "bauer-parse-result.json")
-		if bauerResult != nil && bauerResult.ParseResult != nil {
-			parseResultJSON, err := json.MarshalIndent(bauerResult.ParseResult, "", "  ")
-			if err != nil {
-				output.Status = "failed"
-				output.Errors = append(output.Errors, fmt.Sprintf("failed to marshal parse result: %v", err))
-				output.EndTime = time.Now()
-				output.TotalDuration = output.EndTime.Sub(output.StartTime)
-				return output, err
-			}
-
-			if err := os.WriteFile(outputPath, parseResultJSON, 0644); err != nil {
-				output.Status = "failed"
-				output.Errors = append(output.Errors, fmt.Sprintf("failed to write parse result file: %v", err))
-				output.EndTime = time.Now()
-				output.TotalDuration = output.EndTime.Sub(output.StartTime)
-				return output, err
-			}
-		}
+	if _, err := os.Stat(outputPath); err != nil {
+		output.Status = "failed"
+		output.Errors = append(output.Errors, fmt.Sprintf("parse result file was not created at expected location: %s: %v", outputPath, err))
+		output.EndTime = time.Now()
+		output.TotalDuration = output.EndTime.Sub(output.StartTime)
+		return output, err
+	}
+
+	output.OutputFile = outputPath
+
+	if input.ParseOnly {
+		output.EndTime = time.Now()
+		output.TotalDuration = output.EndTime.Sub(output.StartTime)
+		output.Status = "success"
+		logger.Info("workflow: parse-only mode complete", "output_file", output.OutputFile)
+		return output, nil
+	}
+
+	repo, err := github.ParseGitHubRepo(input.GitHubRepo)
+	if err != nil {
+		output.Status = "failed"
+		output.Errors = append(output.Errors, fmt.Sprintf("invalid github repo: %v", err))
+		output.EndTime = time.Now()
+		output.TotalDuration = output.EndTime.Sub(output.StartTime)
+		return output, err
+	}
 
-		// Verify the file actually exists
-		if _, err := os.Stat(outputPath); err != nil {
+	token := input.GitHubToken
+	if token == "" {
+		token, err = github.GetGitHubToken()
+		if err != nil {
 			output.Status = "failed"
-			output.Errors = append(output.Errors, fmt.Sprintf("parse result file was not created at expected location: %s: %v", outputPath, err))
+			output.Errors = append(output.Errors, fmt.Sprintf("failed to get github token: %v", err))
 			output.EndTime = time.Now()
 			output.TotalDuration = output.EndTime.Sub(output.StartTime)
 			return output, err
 		}
+	}
 
+	if err := github.SetupGitHubAuth(token); err != nil {
+		output.Status = "failed"
+		output.Errors = append(output.Errors, fmt.Sprintf("failed to setup github auth: %v", err))
 		output.EndTime = time.Now()
 		output.TotalDuration = output.EndTime.Sub(output.StartTime)
-		output.Status = "success"
-		output.OutputFile = outputPath
-
-		// Safely compute totalFiles with nil checks
-		totalFiles := 0
-		if bauerResult != nil && bauerResult.ParseResult != nil {
-			totalFiles = len(bauerResult.ParseResult.FileMappings)
-		}
-
-		logger.Info("workflow: Parse-only mode complete",
-			"output_file", output.OutputFile,
-			"extraction_duration", output.BauerResult.ExtractionDuration,
-			"total_suggestions", output.BauerResult.TotalSuggestions,
-			"total_files", totalFiles,
-		)
-
-		return output, nil
+		return output, err
 	}
 
-	// PHASES 2-4: Full workflow with GitHub integration
-	logger.Info("workflow: Setting up GitHub")
+	parseFileContent, err := os.ReadFile(outputPath)
+	if err != nil {
+		output.Status = "failed"
+		output.Errors = append(output.Errors, fmt.Sprintf("failed to read parse result for issue: %v", err))
+		output.EndTime = time.Now()
+		output.TotalDuration = output.EndTime.Sub(output.StartTime)
+		return output, err
+	}
 
-	githubSetupInput := github.GitHubSetupInput{
+	setupInput := github.GitHubSetupInput{
 		GitHubRepo:    input.GitHubRepo,
-		GitHubToken:   input.GitHubToken,
+		GitHubToken:   token,
 		BranchPrefix:  input.BranchPrefix,
 		LocalRepoPath: input.LocalRepoPath,
 	}
-
-	githubSetupOutput, err := github.SetupGitHubPhase(githubSetupInput)
+	setupOutput, err := github.SetupGitHubPhase(setupInput)
 	if err != nil {
 		output.Status = "failed"
-		output.Errors = append(output.Errors, err.Error())
+		output.Errors = append(output.Errors, fmt.Sprintf("failed to prepare branch-backed prompt file: %v", err))
 		output.EndTime = time.Now()
 		output.TotalDuration = output.EndTime.Sub(output.StartTime)
 		return output, err
 	}
-	// Store GH setup results
-	output.RepositoryInfo.Owner = githubSetupOutput.Repo.Owner
-	output.RepositoryInfo.Repo = githubSetupOutput.Repo.Name
-	output.RepositoryInfo.LocalPath = githubSetupOutput.LocalPath
-	output.RepositoryInfo.BranchName = githubSetupOutput.BranchName
-	output.RepositoryInfo.DefaultBranch = githubSetupOutput.DefaultBranch
-	output.RepositoryInfo.CurrentBranch = githubSetupOutput.CurrentBranch
-
-	logger.Info("workflow success: GitHub setup successful")
-
-	// Change to target repository directory
-	// Save original directory to restore later
-	originalDir, err := os.Getwd()
-	if err != nil {
+
+	output.RepositoryInfo.Owner = setupOutput.Repo.Owner
+	output.RepositoryInfo.Repo = setupOutput.Repo.Name
+	output.RepositoryInfo.LocalPath = setupOutput.LocalPath
+	output.RepositoryInfo.BranchName = setupOutput.BranchName
+	output.RepositoryInfo.DefaultBranch = setupOutput.DefaultBranch
+	output.RepositoryInfo.CurrentBranch = setupOutput.CurrentBranch
+
+	// Derive a safe directory name for the prompt file within the repo.
+	repoPromptDir := filepath.Base(filepath.Clean(input.OutputDir))
+	if repoPromptDir == "." {
+		repoPromptDir = ""
+	}
+	repoPromptPath := filepath.ToSlash(filepath.Join(repoPromptDir, filepath.Base(outputPath)))
+
+	targetPromptPath := filepath.Join(setupOutput.LocalPath, filepath.FromSlash(repoPromptPath))
+	if err := os.MkdirAll(filepath.Dir(targetPromptPath), 0755); err != nil {
 		output.Status = "failed"
-		output.Errors = append(output.Errors, fmt.Sprintf("failed to get current directory: %v", err))
+		output.Errors = append(output.Errors, fmt.Sprintf("failed to create prompt file directory in repo: %v", err))
 		output.EndTime = time.Now()
 		output.TotalDuration = output.EndTime.Sub(output.StartTime)
 		return output, err
 	}
-
-	if err := os.Chdir(input.LocalRepoPath); err != nil {
+	if err := os.WriteFile(targetPromptPath, parseFileContent, 0644); err != nil {
 		output.Status = "failed"
-		output.Errors = append(output.Errors, fmt.Sprintf("failed to change to cloned repository: %v", err))
+		output.Errors = append(output.Errors, fmt.Sprintf("failed to write prompt file in repo branch: %v", err))
 		output.EndTime = time.Now()
 		output.TotalDuration = output.EndTime.Sub(output.StartTime)
 		return output, err
 	}
-	logger.Info("workflow: changed to cloned repository", "path", input.LocalRepoPath)
-	defer os.Chdir(originalDir)
-
-	// Bauer processing
-	logger.Info("workflow: starting phase 2 - Bauer processing")
 
-	// Create Bauer config with target repo (now current directory)
-	bauerCfg := &config.Config{
-		DocID:           input.DocID,
-		CredentialsPath: credentialsPath, // Use absolute path
-		DryRun:          input.DryRun,
-		ChunkSize:       input.ChunkSize,
-		PageRefresh:     input.PageRefresh,
-		OutputDir:       input.OutputDir,
-		Model:           input.Model,
-		TargetRepo:      ".", // Current directory is the cloned repo
+	commitMessage := fmt.Sprintf("Add Bauer parse output for doc %s", input.DocID)
+	if err := github.CommitFiles(setupOutput.LocalPath, commitMessage, []string{repoPromptPath}); err != nil {
+		output.Status = "failed"
+		output.Errors = append(output.Errors, fmt.Sprintf("failed to commit branch prompt file: %v", err))
+		output.EndTime = time.Now()
+		output.TotalDuration = output.EndTime.Sub(output.StartTime)
+		return output, err
+	}
+	if err := github.PushBranch(setupOutput.LocalPath, setupOutput.BranchName); err != nil {
+		output.Status = "failed"
+		output.Errors = append(output.Errors, fmt.Sprintf("failed to push branch prompt file: %v", err))
+		output.EndTime = time.Now()
+		output.TotalDuration = output.EndTime.Sub(output.StartTime)
+		return output, err
 	}
 
-	logger.Info("workflow: Bauer target repository set at", "path", bauerCfg.TargetRepo)
+	output.FinalizationInfo.CommitMessage = commitMessage
+	output.FinalizationInfo.BranchPushed = true
 
-	// Execute Bauer orchestration
-	bauerResult, err := orch.Execute(ctx, bauerCfg)
-	if err != nil {
-		output.Status = "partial"
-		output.Errors = append(output.Errors, fmt.Sprintf("Bauer processing error: %v", err))
-		logger.Warn("workflow: Bauer processing returned error", "error", err)
-		// Continue anyway - we can still commit what we have
+	pinnedRef := setupOutput.BranchName
+	if sha, shaErr := github.GetHeadCommitSHA(setupOutput.LocalPath); shaErr == nil && sha != "" {
+		pinnedRef = sha
+	} else if shaErr != nil {
+		output.Warnings = append(output.Warnings, fmt.Sprintf("could not resolve HEAD SHA for pinned prompt link; falling back to branch ref: %v", shaErr))
 	}
 
-	// Store Bauer results
-	if bauerResult != nil {
-		output.BauerResult.ExtractionDuration = bauerResult.ExtractionDuration
-		output.BauerResult.PlanDuration = bauerResult.PlanDuration
-		output.BauerResult.CopilotDuration = bauerResult.CopilotDuration
-		if len(bauerResult.Chunks) > 0 {
-			output.BauerResult.ChunkCount = len(bauerResult.Chunks)
-		}
-		if bauerResult.ExtractionResult != nil {
-			// Count total suggestions from extraction result
-			output.BauerResult.TotalSuggestions = 0 // TODO: adjust based on actual field
-		}
+	branchBlobURL := fmt.Sprintf("https://github.com/%s/%s/blob/%s/%s", setupOutput.Repo.Owner, setupOutput.Repo.Name, setupOutput.BranchName, repoPromptPath)
+	pinnedBlobURL := fmt.Sprintf("https://github.com/%s/%s/blob/%s/%s", setupOutput.Repo.Owner, setupOutput.Repo.Name, pinnedRef, repoPromptPath)
+	rawURL := fmt.Sprintf("https://raw.githubusercontent.com/%s/%s/%s/%s", setupOutput.Repo.Owner, setupOutput.Repo.Name, pinnedRef, repoPromptPath)
+
+	issueTitle := fmt.Sprintf("@copilot Apply Bauer parse result to %s", repo.Name)
+	issueBody := fmt.Sprintf("@copilot\n\nAutomated parse result from Bauer\n\nGDoc ID: %s", input.DocID)
+	if bauerResult != nil && bauerResult.ExtractionResult != nil {
+		issueBody = prompt.BuildIssueDescription(
+			bauerResult.ExtractionResult,
+			bauerResult.Chunks,
+			input.PageRefresh,
+		)
 	}
-
-	logger.Info("Bauer results",
-		"extraction_duration", output.BauerResult.ExtractionDuration,
-		"plan_duration", output.BauerResult.PlanDuration,
-		"copilot_duration", output.BauerResult.CopilotDuration,
-		"chunk_count", output.BauerResult.ChunkCount,
-		"total_suggestions", output.BauerResult.TotalSuggestions,
-	)
-	logger.Info("workflow success: Bauer processing finished")
-
-	// GitHub finalization
-	logger.Info("workflow: GitHub finalization")
-
-	commitMessage := fmt.Sprintf("Apply BAU suggestions from doc %s", input.DocID)
-	prTitle := fmt.Sprintf("Apply BAU suggestions to %s", githubSetupOutput.Repo.Name)
-	prBody := fmt.Sprintf("Automated copy update changes from Bauer\n\nGDoc ID: %s", input.DocID)
-
-	finalizationInput := github.GitHubFinalizationInput{
-		LocalRepoPath: input.LocalRepoPath,
-		BranchName:    githubSetupOutput.BranchName,
-		DefaultBranch: githubSetupOutput.DefaultBranch,
-		Owner:         githubSetupOutput.Repo.Owner,
-		Repo:          githubSetupOutput.Repo.Name,
-		CommitMessage: commitMessage,
-		DryRun:        input.DryRun,
-		PRTitle:       prTitle,
-		PRBody:        prBody,
-		Labels:        []string{},
+	issueBody = issueBody + "\n\n## Prompt Source\n\n" +
+		"Use this branch-backed prompt file as the machine-readable input, together with this issue description.\n\n" +
+		fmt.Sprintf("- Branch file: %s\n", branchBlobURL) +
+		fmt.Sprintf("- Pinned file (commit SHA): %s\n", pinnedBlobURL) +
+		fmt.Sprintf("- Raw JSON: %s\n", rawURL) +
+		fmt.Sprintf("\n\n## Copilot PR Branch\n\nUse `%s` as the head branch for the PR tied to this issue. This is the branch I will assign Copilot to for implementation.\n", setupOutput.BranchName) +
+		fmt.Sprintf("\n\n## Cleanup\n\nOnce the PR is merged or this issue is closed, please delete the branch `%s`.\n", setupOutput.BranchName)
+
+	issueURL, issueWarning, err := createIssueWithFallback(repo.Owner, repo.Name, issueTitle, issueBody)
+	if err != nil {
+		output.Status = "failed"
+		output.Errors = append(output.Errors, fmt.Sprintf("failed to create issue: %v", err))
+		output.EndTime = time.Now()
+		output.TotalDuration = output.EndTime.Sub(output.StartTime)
+		return output, err
+	}
+	if issueWarning != "" {
+		output.Warnings = append(output.Warnings, issueWarning)
 	}
 
-	finalizationOutput, _ := github.FinalizeGitHubPhase(finalizationInput)
+	output.FinalizationInfo.Issue.URL = issueURL
+	output.FinalizationInfo.Issue.Title = issueTitle
 
-	// Store GH PR results
-	output.FinalizationInfo.CommitMessage = finalizationOutput.CommitMessage
-	output.FinalizationInfo.BranchPushed = finalizationOutput.BranchPushed
-	output.FinalizationInfo.PullRequest.URL = finalizationOutput.PullRequest.URL
-	output.FinalizationInfo.PullRequest.Title = finalizationOutput.PullRequest.Title
+	output.EndTime = time.Now()
+	output.TotalDuration = output.EndTime.Sub(output.StartTime)
+	output.Status = "success"
 
-	// Merge warnings and errors from finalization
-	output.Warnings = append(output.Warnings, finalizationOutput.Warnings...)
-	output.Errors = append(output.Errors, finalizationOutput.Errors...)
+	logger.Info("workflow: parse + issue mode complete",
+		"output_file", output.OutputFile,
+		"issue_url", output.FinalizationInfo.Issue.URL,
+		"branch", output.RepositoryInfo.BranchName,
+	)
 
-	logger.Info("workflow: phase 3 complete - GitHub finalization finished")
+	return output, nil
+}
 
-	output.EndTime = time.Now()
-	output.TotalDuration = output.EndTime.Sub(output.StartTime)
+func createIssueWithFallback(owner, repo, title, body string) (issueURL, warning string, err error) {
+	issueURL, err = github.CreateIssue(owner, repo, github.CreateIssueOptions{
+		Title:     title,
+		Body:      body,
+		Assignees: []string{"copilot"},
+		Labels:    []string{"copilot", "bauer"},
+	})
+	if err == nil {
+		return issueURL, "", nil
+	}
 
-	if len(output.Errors) == 0 {
-		output.Status = "success"
-	} else if output.FinalizationInfo.BranchPushed {
-		output.Status = "partial"
-	} else {
-		output.Status = "failed"
+	// Fallback 1: some repos/orgs cannot resolve/assign the "copilot" login.
+	// Assign to copilot label
+	issueURL, err = github.CreateIssue(owner, repo, github.CreateIssueOptions{
+		Title:  title,
+		Body:   body,
+		Labels: []string{"copilot"},
+	})
+	if err == nil {
+		return issueURL, "could not assign issue to 'copilot' and label set {copilot,bauer}; created issue with 'copilot' label only", nil
 	}
 
-	logger.Info("workflow: complete",
-		"status", output.Status,
-		"duration", output.TotalDuration,
-		"errors", len(output.Errors),
-		"warnings", len(output.Warnings),
-	)
+	// Fallback 3: labels may be unavailable in the target repo.
+	issueURL, err = github.CreateIssue(owner, repo, github.CreateIssueOptions{
+		Title: title,
+		Body:  body,
+	})
+	if err == nil {
+		return issueURL, "could not assign issue to 'copilot' and one or more labels were unavailable; created issue without assignee/labels and kept @copilot mention in body", nil
+	}
 
-	return output, nil
+	return "", "", err
 }