feat: add --resume-play to pause-point await flow

cli/project-runner/internal/projectrunner/list_output.go

@@ -183,6 +183,16 @@ func appendPausePointEnableAwaitListOptions(tool clicore.ToolDefinition, options
 			Type:        "string",
 			Description: "Requires --await. Same as await-pause-point's --expect (repeatable)",
 		},
+		listOption{
+			Name:        "--" + PausePointTriggerFlagName,
+			Type:        "string",
+			Description: "Requires --await. Same as await-pause-point's --trigger",
+		},
+		listOption{
+			Name:        "--" + PausePointResumePlayFlagName,
+			Type:        "boolean",
+			Description: "Requires --await. After confirming the marker is armed, resume PlayMode if paused (before --trigger), so a paused-arm workflow can fire input in one call",
+		},
 	)
 }
 

cli/project-runner/internal/projectrunner/list_output_test.go

@@ -147,6 +147,8 @@ func TestNewListCatalogIncludesEnablePausePointAwaitOptions(t *testing.T) {
 	findListOption(t, enablePausePoint, "--"+PausePointCapturedVariablesFlagName)
 	findListOption(t, enablePausePoint, "--"+PausePointCapturedVariableNamesFlagName)
 	findListOption(t, enablePausePoint, "--"+PausePointExpectFlagName)
+	findListOption(t, enablePausePoint, "--"+PausePointTriggerFlagName)
+	findListOption(t, enablePausePoint, "--"+PausePointResumePlayFlagName)
 }
 
 func decodeListCatalog(t *testing.T, content []byte) listCatalog {

cli/project-runner/internal/projectrunner/native_command_help.go

@@ -19,6 +19,7 @@ const (
 	PausePointCapturedVariableNamesFlagName = "captured-variable-names"
 	PausePointExpectFlagName                = "expect"
 	PausePointTriggerFlagName               = "trigger"
+	PausePointResumePlayFlagName            = "resume-play"
 )
 
 // runnerNativeCommandOptions lists the flags accepted by each runner-owned
@@ -34,6 +35,7 @@ var runnerNativeCommandOptions = map[string][]string{
 		"--" + PausePointCapturedVariableNamesFlagName,
 		"--" + PausePointExpectFlagName,
 		"--" + PausePointTriggerFlagName,
+		"--" + PausePointResumePlayFlagName,
 	},
 	clicore.PausePointStatusUserCommandName: {
 		"--" + PausePointIDFlagName,

cli/project-runner/internal/projectrunner/native_command_help_test.go

@@ -20,7 +20,7 @@ func TestRunProjectLocalAwaitPausePointHelpListsExpectedFlags(t *testing.T) {
 	if code != 0 {
 		t.Fatalf("await-pause-point --help failed: code=%d stderr=%s", code, stderr.String())
 	}
-	for _, flag := range []string{"--id", "--timeout-seconds", "--matching-logs-max-count", "--captured-variables", "--expect"} {
+	for _, flag := range []string{"--id", "--timeout-seconds", "--matching-logs-max-count", "--captured-variables", "--expect", "--trigger", "--resume-play"} {
 		if !strings.Contains(stdout.String(), flag) {
 			t.Fatalf("await-pause-point --help must list %s: %s", flag, stdout.String())
 		}

cli/project-runner/internal/projectrunner/pause_point_enable.go

@@ -25,11 +25,12 @@ const pausePointEnableCommandName = "enable-pause-point"
 const pausePointEnableAwaitFlagName = "await"
 
 // extractPausePointEnableAwaitFlags pulls the CLI-only --await/--captured-variables/
-// --captured-variable-names/--expect/--trigger flags out of enable-pause-point args before
-// generic schema parsing, because none of them are part of the Unity-side EnablePausePointSchema.
+// --captured-variable-names/--expect/--trigger/--resume-play flags out of enable-pause-point args
+// before generic schema parsing, because none of them are part of the Unity-side
+// EnablePausePointSchema.
 func extractPausePointEnableAwaitFlags(
 	args []string,
-) ([]string, bool, pausePointCapturedVariablesMode, []string, []pausePointExpectation, string, []string, error) {
+) ([]string, bool, pausePointCapturedVariablesMode, []string, []pausePointExpectation, string, []string, bool, error) {
 	remaining := make([]string, 0, len(args))
 	await := false
 	mode := pausePointCapturedVariablesModeFull
@@ -40,6 +41,7 @@ func extractPausePointEnableAwaitFlags(
 	var triggerCommand string
 	var triggerArgs []string
 	triggerSet := false
+	resumePlay := false
 
 	for index := 0; index < len(args); index++ {
 		arg := args[index]
@@ -49,18 +51,45 @@ func extractPausePointEnableAwaitFlags(
 			continue
 		}
 
+		if arg == "--"+PausePointResumePlayFlagName {
+			resumePlay = true
+			continue
+		}
+
+		// --resume-play=true|1 must be accepted here too: otherwise the =value form falls through
+		// to Unity schema parsing and becomes a confusing unrelated error.
+		if isPausePointFlag(arg, PausePointResumePlayFlagName) {
+			name, value, consumedNext, err := clicore.ParseFlagValue(arg, args, index)
+			if err != nil {
+				return nil, false, mode, nil, nil, "", nil, false, err
+			}
+			if name != PausePointResumePlayFlagName {
+				remaining = append(remaining, arg)
+				continue
+			}
+			if value != "true" && value != "1" {
+				return nil, false, mode, nil, nil, "", nil, false, clierrors.InvalidValueArgumentError(
+					"--"+PausePointResumePlayFlagName, value, "boolean flag (pass with no value, or =true)")
+			}
+			resumePlay = true
+			if consumedNext {
+				index++
+			}
+			continue
+		}
+
 		if isPausePointFlag(arg, PausePointTriggerFlagName) {
 			name, value, consumedNext, err := clicore.ParseFlagValue(arg, args, index)
 			if err != nil {
-				return nil, false, mode, nil, nil, "", nil, err
+				return nil, false, mode, nil, nil, "", nil, false, err
 			}
 			if name != PausePointTriggerFlagName {
 				remaining = append(remaining, arg)
 				continue
 			}
 			parsedCommand, parsedArgs, parseErr := parsePausePointTriggerCommand(pausePointEnableCommandName, value)
 			if parseErr != nil {
-				return nil, false, mode, nil, nil, "", nil, parseErr
+				return nil, false, mode, nil, nil, "", nil, false, parseErr
 			}
 			triggerCommand = parsedCommand
 			triggerArgs = parsedArgs
@@ -74,15 +103,15 @@ func extractPausePointEnableAwaitFlags(
 		if isPausePointFlag(arg, PausePointCapturedVariablesFlagName) {
 			name, value, consumedNext, err := clicore.ParseFlagValue(arg, args, index)
 			if err != nil {
-				return nil, false, mode, nil, nil, "", nil, err
+				return nil, false, mode, nil, nil, "", nil, false, err
 			}
 			if name != PausePointCapturedVariablesFlagName {
 				remaining = append(remaining, arg)
 				continue
 			}
 			parsedMode, err := parsePausePointCapturedVariablesMode(value)
 			if err != nil {
-				return nil, false, mode, nil, nil, "", nil, err
+				return nil, false, mode, nil, nil, "", nil, false, err
 			}
 			mode = parsedMode
 			modeSet = true
@@ -95,7 +124,7 @@ func extractPausePointEnableAwaitFlags(
 		if isPausePointFlag(arg, PausePointCapturedVariableNamesFlagName) {
 			name, value, consumedNext, err := clicore.ParseFlagValue(arg, args, index)
 			if err != nil {
-				return nil, false, mode, nil, nil, "", nil, err
+				return nil, false, mode, nil, nil, "", nil, false, err
 			}
 			if name != PausePointCapturedVariableNamesFlagName {
 				remaining = append(remaining, arg)
@@ -112,15 +141,15 @@ func extractPausePointEnableAwaitFlags(
 		if isPausePointFlag(arg, PausePointExpectFlagName) {
 			name, value, consumedNext, err := clicore.ParseFlagValue(arg, args, index)
 			if err != nil {
-				return nil, false, mode, nil, nil, "", nil, err
+				return nil, false, mode, nil, nil, "", nil, false, err
 			}
 			if name != PausePointExpectFlagName {
 				remaining = append(remaining, arg)
 				continue
 			}
 			expectation, parseErr := parsePausePointExpectFlagValue(value)
 			if parseErr != nil {
-				return nil, false, mode, nil, nil, "", nil, parseErr
+				return nil, false, mode, nil, nil, "", nil, false, parseErr
 			}
 			expectations = append(expectations, expectation)
 			if consumedNext {
@@ -132,18 +161,20 @@ func extractPausePointEnableAwaitFlags(
 		remaining = append(remaining, arg)
 	}
 
-	if !await && (modeSet || namesSet || len(expectations) > 0 || triggerSet) {
+	if !await && (modeSet || namesSet || len(expectations) > 0 || triggerSet || resumePlay) {
 		option := "--" + PausePointCapturedVariablesFlagName
 		switch {
+		case resumePlay:
+			option = "--" + PausePointResumePlayFlagName
 		case triggerSet:
 			option = "--" + PausePointTriggerFlagName
 		case len(expectations) > 0:
 			option = "--" + PausePointExpectFlagName
 		case namesSet:
 			option = "--" + PausePointCapturedVariableNamesFlagName
 		}
-		return nil, false, mode, nil, nil, "", nil, &clierrors.ArgumentError{
-			Message: "--captured-variables, --captured-variable-names, --expect, and --trigger require --await",
+		return nil, false, mode, nil, nil, "", nil, false, &clierrors.ArgumentError{
+			Message: "--captured-variables, --captured-variable-names, --expect, --trigger, and --resume-play require --await",
 			Option:  option,
 			Command: pausePointEnableCommandName,
 			NextActions: []string{
@@ -152,7 +183,7 @@ func extractPausePointEnableAwaitFlags(
 		}
 	}
 
-	return remaining, await, mode, capturedVariableNames, expectations, triggerCommand, triggerArgs, nil
+	return remaining, await, mode, capturedVariableNames, expectations, triggerCommand, triggerArgs, resumePlay, nil
 }
 
 func isPausePointFlag(arg string, flagName string) bool {
@@ -167,7 +198,7 @@ func runEnablePausePointCommand(
 	stdout io.Writer,
 	stderr io.Writer,
 ) int {
-	remainingArgs, await, capturedVariablesMode, capturedVariableNames, expectations, triggerCommand, triggerArgs, err := extractPausePointEnableAwaitFlags(args)
+	remainingArgs, await, capturedVariablesMode, capturedVariableNames, expectations, triggerCommand, triggerArgs, resumePlay, err := extractPausePointEnableAwaitFlags(args)
 	if err != nil {
 		clierrors.WriteClassifiedError(stderr, err, clierrors.ErrorContext{
 			ProjectRoot: connection.ProjectRoot,
@@ -220,7 +251,7 @@ func runEnablePausePointCommand(
 
 	return runEnablePausePointAndAwait(
 		ctx, connection, params, capturedVariablesMode, capturedVariableNames, expectations,
-		triggerCommand, triggerArgs, startPath, stdout, stderr)
+		triggerCommand, triggerArgs, resumePlay, startPath, stdout, stderr)
 }
 
 // runEnablePausePointAndAwait sends the same single enable-pause-point IPC request the
@@ -236,6 +267,7 @@ func runEnablePausePointAndAwait(
 	expectations []pausePointExpectation,
 	triggerCommand string,
 	triggerArgs []string,
+	resumePlay bool,
 	startPath string,
 	stdout io.Writer,
 	stderr io.Writer,
@@ -288,6 +320,7 @@ func runEnablePausePointAndAwait(
 		triggerCommand:        triggerCommand,
 		triggerArgs:           triggerArgs,
 		startPath:             startPath,
+		resumePlay:            resumePlay,
 	}
 
 	return runPausePointWaitAfterEnable(ctx, connection, waitOptions, enableResponse.Warning, stdout, stderr)
@@ -306,7 +339,7 @@ func runPausePointWaitAfterEnable(
 	stderr io.Writer,
 ) int {
 	spinner := clicore.NewToolSpinner(stderr, pausePointEnableCommandName)
-	response, state, triggerResult, err := waitForPausePoint(ctx, connection, options)
+	response, state, triggerResult, resumeResult, err := waitForPausePoint(ctx, connection, options)
 	spinner.Stop()
 	if err != nil {
 		clierrors.WriteClassifiedError(stderr, err, clierrors.ErrorContext{
@@ -322,6 +355,7 @@ func runPausePointWaitAfterEnable(
 		expectations := evaluatePausePointExpectations(response.CapturedVariables, options.expectations)
 
 		response.TriggerResult = triggerResult
+		response.ResumePlayResult = resumeResult
 		response = filterPausePointCapturedVariableHistory(response)
 		response = filterPausePointCapturedVariablesByName(response, options.capturedVariableNames)
 		response = applyPausePointCapturedVariablesMode(response, options.capturedVariablesMode)
@@ -379,6 +413,9 @@ func runPausePointWaitAfterEnable(
 	if triggerResult != nil {
 		waitErr.Details["TriggerResult"] = triggerResult
 	}
+	if resumeResult != nil {
+		waitErr.Details["ResumePlayResult"] = resumeResult
+	}
 	if state == pausePointWaitStateTimeout {
 		logs, logsErr := fetchMatchingLogs(ctx, connection, options.id, options.matchingLogsMaxCount)
 		if logsErr == nil {

cli/project-runner/internal/projectrunner/pause_point_enable_test.go

@@ -16,7 +16,7 @@ import (
 
 // Verifies --await is extracted and the remaining args are left untouched for schema parsing.
 func TestExtractPausePointEnableAwaitFlagsExtractsAwait(t *testing.T) {
-	remaining, await, mode, names, expectations, _, _, err := extractPausePointEnableAwaitFlags([]string{"--id", "jump", "--await"})
+	remaining, await, mode, names, expectations, _, _, _, err := extractPausePointEnableAwaitFlags([]string{"--id", "jump", "--await"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -39,7 +39,7 @@ func TestExtractPausePointEnableAwaitFlagsExtractsAwait(t *testing.T) {
 
 // Verifies --captured-variables/--captured-variable-names are extracted alongside --await.
 func TestExtractPausePointEnableAwaitFlagsExtractsCapturedVariableOptions(t *testing.T) {
-	remaining, await, mode, names, _, _, _, err := extractPausePointEnableAwaitFlags([]string{
+	remaining, await, mode, names, _, _, _, _, err := extractPausePointEnableAwaitFlags([]string{
 		"--id", "jump", "--await", "--captured-variables", "names", "--captured-variable-names", "a,b",
 	})
 	if err != nil {
@@ -61,7 +61,7 @@ func TestExtractPausePointEnableAwaitFlagsExtractsCapturedVariableOptions(t *tes
 
 // Verifies --expect is extracted (repeatably) alongside --await, and unrelated args are untouched.
 func TestExtractPausePointEnableAwaitFlagsExtractsExpect(t *testing.T) {
-	remaining, await, _, _, expectations, _, _, err := extractPausePointEnableAwaitFlags([]string{
+	remaining, await, _, _, expectations, _, _, _, err := extractPausePointEnableAwaitFlags([]string{
 		"--id", "jump", "--await", "--expect", "Health=100", "--expect", "Name=Enemy",
 	})
 	if err != nil {
@@ -86,7 +86,7 @@ func TestExtractPausePointEnableAwaitFlagsExtractsExpect(t *testing.T) {
 
 // Verifies --captured-variables without --await is rejected, since it has no effect otherwise.
 func TestExtractPausePointEnableAwaitFlagsRequiresAwaitForCapturedVariables(t *testing.T) {
-	_, _, _, _, _, _, _, err := extractPausePointEnableAwaitFlags([]string{"--id", "jump", "--captured-variables", "names"})
+	_, _, _, _, _, _, _, _, err := extractPausePointEnableAwaitFlags([]string{"--id", "jump", "--captured-variables", "names"})
 	if err == nil {
 		t.Fatalf("expected an error")
 	}
@@ -97,7 +97,7 @@ func TestExtractPausePointEnableAwaitFlagsRequiresAwaitForCapturedVariables(t *t
 
 // Verifies --expect without --await is rejected, since it has no effect otherwise.
 func TestExtractPausePointEnableAwaitFlagsRequiresAwaitForExpect(t *testing.T) {
-	_, _, _, _, _, _, _, err := extractPausePointEnableAwaitFlags([]string{"--id", "jump", "--expect", "Health=100"})
+	_, _, _, _, _, _, _, _, err := extractPausePointEnableAwaitFlags([]string{"--id", "jump", "--expect", "Health=100"})
 	if err == nil {
 		t.Fatalf("expected an error")
 	}
@@ -108,7 +108,7 @@ func TestExtractPausePointEnableAwaitFlagsRequiresAwaitForExpect(t *testing.T) {
 
 // Verifies enable-pause-point without --await leaves File/Line/Id/Mode args untouched.
 func TestExtractPausePointEnableAwaitFlagsWithoutAwaitLeavesArgsUnchanged(t *testing.T) {
-	remaining, await, _, _, _, _, _, err := extractPausePointEnableAwaitFlags([]string{"--file", "Assets/Foo.cs", "--line", "10"})
+	remaining, await, _, _, _, _, _, _, err := extractPausePointEnableAwaitFlags([]string{"--file", "Assets/Foo.cs", "--line", "10"})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}