AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference='Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
# The first two authored distributions both have weighted score 1.0, but very different spread.
function New-DraftFixture([double]$P0,[double]$P1,[double]$P2,[double]$Confidence=0.9) {
    [pscustomobject]@{answers=@{readiness=@{type='score';score=$P1+2*$P2;confidence=$Confidence;probabilities=@{'0'=$P0;'1'=$P1;'2'=$P2}}}}
}
$focused=Get-DraftReviewRoute -Draft 'A workable sample draft.' -Fixture (New-DraftFixture 0.05 0.9 0.05)
$split=Get-DraftReviewRoute -Draft 'A contradictory sample draft.' -Fixture (New-DraftFixture 0.49 0.02 0.49)
$lowConfidence=Get-DraftReviewRoute -Draft 'A second sample draft.' -Fixture (New-DraftFixture 0.05 0.05 0.9 0.6)
if($focused.ReportedScore -ne 1 -or $split.ReportedScore -ne 1 -or $focused.Route -ne 'Polish draft' -or $split.Route -ne 'Human review' -or $lowConfidence.Route -ne 'Human review') { throw 'Distribution-aware routing failed.' }
@($focused,$split,$lowConfidence) | Format-Table Mode,ReportedScore,Confidence,PeakLevel,PeakProbability,Route -AutoSize
# Exercise the real module's current local Mock; its keyword score is intentionally simplistic.
$mock=Get-DraftReviewRoute -Draft 'urgent' -Mode Mock
if($mock.Mode -ne 'Mock' -or $mock.Route -ne 'Editor review' -or $mock.PeakProbability -ne 0.82) { throw 'Current Jev Mock contract failed.' }
"Actual Jev Mock: score=$($mock.ReportedScore), peak=$($mock.PeakProbability), confidence=$($mock.Confidence), route=$($mock.Route)"
# Cover each local route and the inclusive peak threshold without an API request.
foreach($sample in @(@(1,0,0,'Rewrite draft'),@(0,0.2,0.8,'Editor review'))) {
    $r=Get-DraftReviewRoute -Draft 'test' -Fixture (New-DraftFixture $sample[0] $sample[1] $sample[2] 0.8)
    if($r.Route -ne $sample[3]) { throw 'Boundary or route check failed.' }
}
foreach($bad in @($null,'0.9',[double]::NaN,1.1)) {
    $f=New-DraftFixture 0.05 0.9 0.05
    $f.answers.readiness.probabilities['1']=$bad
    $blocked=$false
    try { Get-DraftReviewRoute -Draft 'test' -Fixture $f | Out-Null } catch { $blocked=$true }
    if(-not $blocked) { throw 'Invalid probability accepted.' }
}
$blocked=$false
try { Get-DraftReviewRoute -Draft 'test' -Fixture (New-DraftFixture 0.2 0.2 0.2) | Out-Null } catch { $blocked=$true }
if(-not $blocked) { throw 'Invalid probability sum accepted.' }
'Checks passed: equal-score different-spread fixtures, separate confidence gate, all three routes, inclusive 0.8 boundary, real Jev Mock, malformed mass rejection.'
'Live API not called. Fixtures test policy; Mock tests wiring. Neither measures prediction quality or calibration.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Retain a Jev rating but inspect its distribution before routing a fictional how-to draft.
function Get-DraftReviewRoute {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)][string] $Draft,
        [ValidateSet('Fixture','Mock')][string] $Mode='Fixture',
        [object] $Fixture
    )
    Import-Module Jev -MinimumVersion 0.4.0 -ErrorAction Stop
    $levels=@('Missing essential steps; rewrite the draft.','Workable draft that needs polishing.','Clear repeatable steps ready for an editor to check.')
    $question=New-JevQuestion -Name readiness -Type Score -Instructions 'Rate how complete and repeatable this fictional craft tutorial is. Use only the supplied text.' -Criteria $levels
    # The default replays authored answers. Mock calls the current module offline; no Live mode exists.
    $response=if($Mode -eq 'Mock') {
        Invoke-Jev -State $Draft -Question $question -Raw -Mock -ErrorAction Stop
    } else {
        if($null -eq $Fixture) { throw 'Fixture mode needs a response.' }
        $Fixture
    }
    $answer=$response.answers.readiness
    if($null -eq $answer -or $answer.type -cne 'score') { throw 'Missing Score answer.' }
    # Reject coercible strings and booleans instead of treating them as reliable numeric evidence.
    foreach($field in @('score','confidence')) {
        $value=$answer.$field
        if($null -eq $value -or $value -isnot [ValueType] -or $value -is [bool] -or [double]::IsNaN([double]$value) -or [double]::IsInfinity([double]$value)) { throw "Invalid $field." }
    }
    if($answer.score -lt 0 -or $answer.score -gt 2 -or $answer.confidence -lt 0 -or $answer.confidence -gt 1) { throw 'Score or confidence outside range.' }
    $mass=[double[]]::new(3)
    $keys=if($answer.probabilities -is [Collections.IDictionary]) { @($answer.probabilities.Keys) } else { @($answer.probabilities.PSObject.Properties.Name) }
    if($keys.Count -ne 3 -or @($keys | Where-Object { [string]$_ -notin @('0','1','2') }).Count) { throw 'Expected exactly three level probabilities.' }
    for($i=0;$i -lt 3;$i++) {
        $key=[string]$i
        $value=$answer.probabilities.$key
        if($null -eq $value -or $value -isnot [ValueType] -or $value -is [bool]) { throw 'Missing numeric probability.' }
        $p=[double]$value
        if([double]::IsNaN($p) -or [double]::IsInfinity($p) -or $p -lt 0 -or $p -gt 1) { throw 'Invalid probability.' }
        $mass[$i]=$p
    }
    if([math]::Abs(($mass | Measure-Object -Sum).Sum-1) -gt 0.0001) { throw 'Probabilities do not sum to one.' }
    # The mode, expected score, and confidence answer different questions. Do not substitute one for another.
    $best=0
    for($i=1;$i -lt 3;$i++) { if($mass[$i] -gt $mass[$best]) { $best=$i } }
    $routes=@('Rewrite draft','Polish draft','Editor review')
    $route=if($mass[$best] -ge 0.8 -and $answer.confidence -ge 0.8) { $routes[$best] } else { 'Human review' }
    [pscustomobject]@{
        Mode=$Mode;ReportedScore=[double]$answer.score;Confidence=[double]$answer.confidence
        PeakLevel=$best;PeakProbability=$mass[$best];Route=$route
    }
    # These illustrative bands never publish anything and do not certify accuracy or calibration.
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:

Mode    ReportedScore Confidence PeakLevel PeakProbability Route
----    ------------- ---------- --------- --------------- -----
Fixture          1.00       0.90         1            0.90 Polish draft
Fixture          1.00       0.90         0            0.49 Human review
Fixture          1.85       0.60         2            0.90 Human review

Actual Jev Mock: score=2, peak=0.82, confidence=0.86, route=Editor review
Checks passed: equal-score different-spread fixtures, separate confidence gate, all three routes, inclusive 0.8 boundary, real Jev Mock, malformed mass rejection.
Live API not called. Fixtures test policy; Mock tests wiring. Neither measures prediction quality or calibration.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference='Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$path=Join-Path ([IO.Path]::GetTempPath()) ('route-mix-'+[guid]::NewGuid().ToString('N')+'.xlsx')
$result=Export-RouteMixWorkbook -Path $path
$package=Open-ExcelPackage -Path $result.Path
try {
    $routes=$package.Workbook.Worksheets['Routes'];$summary=$package.Workbook.Worksheets['Comparison']
    if($package.Workbook.Worksheets.Count -ne 2 -or $routes.Dimension.End.Row -ne 5) { throw 'Workbook layout failed.' }
    foreach($test in @(@('D2',12),@('D3',23.3),@('E2',12),@('E3',9.7))) {
        if([math]::Abs([double]$summary.Cells[$test[0]].Value-$test[1]) -gt 0.0001) { throw "Wrong saved average: $($test[0])" }
    }
    $formulas=@($routes.Cells['E2:E5'] | Where-Object Formula).Count+@($summary.Cells['B2:E3'] | Where-Object Formula).Count
    if($formulas -ne 12 -or $routes.ConditionalFormatting.Count -ne 1 -or $summary.ConditionalFormatting.Count -ne 1) { throw 'Formula or formatting contract failed.' }
    'Short route: 10 -> 8 minutes. Long route: 30 -> 25 minutes.'
    'Actual overall average: 12.00 -> 23.30 minutes. Both routes improved; the work mix changed.'
    'At the same 90% short / 10% long mix: 12.00 -> 9.70 minutes.'
    # Change the after-period trip counts in memory and recalculate to verify editable formulas.
    $routes.Cells['C4'].Value=90;$routes.Cells['C5'].Value=10
    [OfficeOpenXml.CalculationExtension]::Calculate($package.Workbook)
    if([math]::Abs([double]$summary.Cells['D3'].Value-9.7) -gt 0.0001) { throw 'Changed-mix calculation failed.' }
    'What-if: restore the old trip mix -> the actual after average becomes 9.70.'
    # Leave the saved workbook on the original scenario; the what-if is not saved.
} finally { $package.Dispose() }
$blocked=$false
try { Export-RouteMixWorkbook -Path $path | Out-Null } catch { $blocked=$true }
if(-not $blocked) { throw 'Overwrite was allowed.' }
'Checks passed: saved XLSX reopened, two sheets, four rows, 12 formulas, two formatting rules, weighted totals, fixed-mix comparison, editable what-if, overwrite rejection.'
'One new workbook retained in the temporary directory; no desktop Excel or deletion used.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Build an inspectable workbook showing how a changed work mix can reverse an overall average.
function Export-RouteMixWorkbook {
    [CmdletBinding()]
    param([Parameter(Mandatory)][string] $Path)
    Import-Module ImportExcel -MinimumVersion 7.8.10 -ErrorAction Stop
    # A unique new path prevents accidental replacement of an existing workbook.
    if(Test-Path -LiteralPath $Path) { throw 'Choose a new output path; existing workbooks are not overwritten.' }
    $data=@(
        [pscustomobject][ordered]@{Period='Before';Route='Short';Trips=90;MinutesPerTrip=10;TotalMinutes=0},
        [pscustomobject][ordered]@{Period='Before';Route='Long';Trips=10;MinutesPerTrip=30;TotalMinutes=0},
        [pscustomobject][ordered]@{Period='After';Route='Short';Trips=10;MinutesPerTrip=8;TotalMinutes=0},
        [pscustomobject][ordered]@{Period='After';Route='Long';Trips=90;MinutesPerTrip=25;TotalMinutes=0}
    )
    $package=$data | Export-Excel -Path $Path -WorksheetName Routes -TableName RouteSamples -BoldTopRow -FreezeTopRow -PassThru
    try {
        $routes=$package.Workbook.Worksheets['Routes']
        foreach($col in 1..5) { $routes.Column($col).Width=22 }
        for($row=2;$row -le 5;$row++) { $routes.Cells[$row,5].Formula="C$row*D$row" }
        Add-ConditionalFormatting -Worksheet $routes -Address 'D2:D5' -DataBarColor Blue | Out-Null
        $summary=Add-Worksheet -ExcelPackage $package -WorksheetName Comparison
        $headers=@('Period','Trips','Total minutes','Actual average','Same-mix average')
        for($col=1;$col -le $headers.Count;$col++) { $summary.Cells[1,$col].Value=$headers[$col];$summary.Column($col).Width=23 }
        $summary.Cells['A1:E1'].Style.Font.Bold=$true
        $summary.Cells['A2'].Value='Before';$summary.Cells['A3'].Value='After'
        # Weighted averages divide total minutes by trips; averaging the two means ignores work volume.
        $summary.Cells['B2'].Formula='SUM(Routes!C2:C3)';$summary.Cells['B3'].Formula='SUM(Routes!C4:C5)'
        $summary.Cells['C2'].Formula='SUM(Routes!E2:E3)';$summary.Cells['C3'].Formula='SUM(Routes!E4:E5)'
        $summary.Cells['D2'].Formula='C2/B2';$summary.Cells['D3'].Formula='C3/B3'
        # Hold the old 90/10 route mix fixed to make an apples-to-apples comparison.
        $summary.Cells['A6'].Value='Fixed short-route share';$summary.Cells['B6'].Value=0.9
        $summary.Cells['B6'].Style.Numberformat.Format='0%'
        $summary.Cells['E2'].Formula='Routes!D2*$B$6+Routes!D3*(1-$B$6)'
        $summary.Cells['E3'].Formula='Routes!D4*$B$6+Routes!D5*(1-$B$6)'
        $summary.Cells['D2:E3'].Style.Numberformat.Format='0.00'
        Add-ConditionalFormatting -Worksheet $summary -Address 'D3' -RuleType Expression -ConditionValue 'D3>D2' -BackgroundColor LightYellow | Out-Null
        # Compute cached formula values so the result can be checked without desktop Excel.
        [OfficeOpenXml.CalculationExtension]::Calculate($package.Workbook)
        $package.Save()
    } finally { $package.Dispose() }
    [pscustomobject]@{Path=$Path;Rows=4}
    # No causal claim: these fictional group means illustrate mix effects, not driver performance.
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
WARNING: ImportExcel Module Cannot Autosize. Please run the following command to install dependencies:
apt-get -y update && apt-get install -y --no-install-recommends libgdiplus libc6-dev
Short route: 10 -> 8 minutes. Long route: 30 -> 25 minutes.
Actual overall average: 12.00 -> 23.30 minutes. Both routes improved; the work mix changed.
At the same 90% short / 10% long mix: 12.00 -> 9.70 minutes.
What-if: restore the old trip mix -> the actual after average becomes 9.70.
Checks passed: saved XLSX reopened, two sheets, four rows, 12 formulas, two formatting rules, weighted totals, fixed-mix comparison, editable what-if, overwrite rejection.
One new workbook retained in the temporary directory; no desktop Excel or deletion used.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference='Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$parcels=@(
    [pscustomobject]@{Id='P-01';City='Maple Bay'},
    [pscustomobject]@{Id='P-02';City='Harbor Hill'},
    [pscustomobject]@{Id=' p-01 ';City='Maple Bay'},
    [pscustomobject]@{Id='P-03';City='Cedar Cove'}
)
$before=ConvertTo-Json -InputObject $parcels -Compress
# Capture information separately while keeping the success stream available as typed data.
$data=@(New-ParcelLabelRecord -Parcels $parcels -InformationVariable trace -InformationAction SilentlyContinue)
if ($data.Count -ne 3 -or @($data | Where-Object {$_ -isnot [pscustomobject]}).Count) { throw 'Success stream contains a stowaway.' }
if (@($trace).Count -ne 4) { throw 'Information stream capture failed.' }
$json=ConvertTo-Json -InputObject $data -Compress
$decoded=@($json | ConvertFrom-Json)
if ($decoded.Count -ne 3 -or $decoded[1].Id -ne 'P-02') { throw 'JSON roundtrip failed.' }
if ($json -match 'Prepared parcel|Skipped repeat') { throw 'Progress text leaked into JSON.' }
if ($before -cne (ConvertTo-Json -InputObject $parcels -Compress)) { throw 'Inputs changed.' }
'Data stream: 3 parcel objects'
'Information stream: 4 progress records'
$json
'Progress captured separately:'
$trace | ForEach-Object { [string]$_.MessageData }
# Every cardinality uses an explicit array at the caller; the function does not emit fake placeholders.
if (@(New-ParcelLabelRecord -Parcels @()).Count -ne 0) { throw 'Empty batch failed.' }
if (@(New-ParcelLabelRecord -Parcels @($parcels[0])).Count -ne 1) { throw 'Single batch failed.' }
$bad=$false
try { New-ParcelLabelRecord -Parcels @([pscustomobject]@{Id='';City='test'}) | Out-Null } catch { $bad=$true }
if (-not $bad) { throw 'Blank ID accepted.' }
'Checks passed: typed-only output, separate information records, JSON roundtrip, stable first occurrence, zero/one/many results, blank ID rejection, unchanged inputs.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Keep reusable label objects on stream 1 and human progress messages on stream 6.
function New-ParcelLabelRecord {
    [CmdletBinding()]
    param([Parameter(Mandatory)][AllowEmptyCollection()][object[]] $Parcels)
    # Validate all identifiers before producing partial output; case is ignored for duplicates.
    $seen = [System.Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
    foreach ($parcel in $Parcels) {
        if ([string]::IsNullOrWhiteSpace([string]$parcel.Id)) { throw 'Every parcel needs an ID.' }
        if ([string]::IsNullOrWhiteSpace([string]$parcel.City)) { throw 'Every parcel needs a city.' }
    }
    foreach ($parcel in $Parcels) {
        $id = ([string]$parcel.Id).Trim()
        # HashSet.Add returns a Boolean. Capture it so that it cannot leak into the data stream.
        $isNew = $seen.Add($id)
        if (-not $isNew) {
            Write-Information -MessageData "Skipped repeat parcel $id" -Tags 'LabelPrep'
            continue
        }
        # Information records remain separate unless the caller explicitly merges streams with 6>&1.
        Write-Information -MessageData "Prepared parcel $id" -Tags 'LabelPrep'
        [pscustomobject][ordered]@{
            Id = $id
            City = ([string]$parcel.City).Trim()
            LabelText = ('{0} | {1}' -f $id,([string]$parcel.City).Trim())
        }
    }
    # No formatting, JSON serialization, or files here. The caller controls presentation and storage.
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
Data stream: 3 parcel objects
Information stream: 4 progress records
[{"Id":"P-01","City":"Maple Bay","LabelText":"P-01 | Maple Bay"},{"Id":"P-02","City":"Harbor Hill","LabelText":"P-02 | Harbor Hill"},{"Id":"P-03","City":"Cedar Cove","LabelText":"P-03 | Cedar Cove"}]
Progress captured separately:
Prepared parcel P-01
Prepared parcel P-02
Skipped repeat parcel p-01
Prepared parcel P-03
Checks passed: typed-only output, separate information records, JSON roundtrip, stable first occurrence, zero/one/many results, blank ID rejection, unchanged inputs.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference='Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$cases=@(
    [pscustomobject]@{Name='Tiny note';Text='ok'},
    [pscustomobject]@{Name='Repeated status';Text=('Parcel ready; shelf blue; gate seven. '*250)},
    [pscustomobject]@{Name='Accented text';Text=('Cafe déjà vu. '*150)},
    [pscustomobject]@{Name='Empty';Text=''}
)
$results=@($cases | ForEach-Object {
    $m=Measure-TextCompression -Text $_.Text
    [pscustomobject]@{Case=$_.Name;Plain=$m.PlainBytes;GZip=$m.GZipBytes;Base64=$m.Base64Bytes;SavingPct=$m.SavingPct;Selected=$m.Selected}
})
$results | Format-Table -AutoSize
if($results[0].Selected -ne 'Plain UTF-8' -or $results[0].Base64 -le $results[0].Plain) { throw 'Tiny-text overhead not demonstrated.' }
if($results[1].Selected -ne 'GZip + Base64' -or $results[1].SavingPct -lt 90) { throw 'Repetitive-text savings failed.' }
if($results[2].Selected -ne 'GZip + Base64' -or $results[3].Selected -ne 'Plain UTF-8') { throw 'UTF-8 or empty policy failed.' }
$a=Measure-TextCompression -Text 'same text'
$b=Measure-TextCompression -Text 'same text'
if($a.Base64Bytes -ne $b.Base64Bytes) { throw 'Repeated measurement changed.' }
'Checks passed: four lossless roundtrips, tiny-message expansion, repeated-text savings, UTF-8 text, empty input, repeatable sizes.'
'Size comparison excludes protocol headers and decoding cost. Compression is not encryption; no data was transmitted.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Measure a text-friendly compression envelope before deciding whether to use it.
function Measure-TextCompression {
    [CmdletBinding()]
    param([Parameter(Mandatory)][AllowEmptyString()][ValidateLength(0,16000)][string] $Text)
    # Compare UTF-8 plaintext bytes with ASCII Base64 of a GZip payload, excluding protocol wrappers.
    $bytes=[Text.Encoding]::UTF8.GetBytes($Text)
    $buffer=[IO.MemoryStream]::new()
    try {
        $gzip=[IO.Compression.GZipStream]::new($buffer,[IO.Compression.CompressionLevel]::Optimal,$true)
        try { $gzip.Write($bytes,0,$bytes.Length) } finally { $gzip.Dispose() }
        $packed=$buffer.ToArray()
    } finally { $buffer.Dispose() }
    $encoded=[Convert]::ToBase64String($packed)
    # Verify only the payload created above, never accept or inflate arbitrary external compressed data.
    $source=[IO.MemoryStream]::new($packed,$false)
    $restored=[IO.MemoryStream]::new()
    try {
        $unzip=[IO.Compression.GZipStream]::new($source,[IO.Compression.CompressionMode]::Decompress)
        try { $unzip.CopyTo($restored) } finally { $unzip.Dispose() }
        $roundtrip=[Text.Encoding]::UTF8.GetString($restored.ToArray())
        if ($roundtrip -cne $Text) { throw 'Text did not survive compression.' }
    } finally { $source.Dispose(); $restored.Dispose() }
    # Empty input has no percentage denominator. Require at least 10% savings for nonempty text.
    $saving=if($bytes.Length) { 1.0-$encoded.Length/$bytes.Length } else { 0.0 }
    $mode=if($bytes.Length -and $saving -ge 0.1) { 'GZip + Base64' } else { 'Plain UTF-8' }
    [pscustomobject]@{
        PlainBytes=$bytes.Length; GZipBytes=$packed.Length; Base64Bytes=$encoded.Length
        SavingPct=[math]::Round(100*$saving,2); Selected=$mode; Roundtrip=$true
    }
    # This is a size decision, not encryption or a benchmark of network transfer time.
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:

Case            Plain GZip Base64 SavingPct Selected
----            ----- ---- ------ --------- --------
Tiny note           2   22     32  -1500.00 Plain UTF-8
Repeated status  9500  141    188     98.02 GZip + Base64
Accented text    2400   65     88     96.33 GZip + Base64
Empty               0    0      0      0.00 Plain UTF-8

Checks passed: four lossless roundtrips, tiny-message expansion, repeated-text savings, UTF-8 text, empty input, repeatable sizes.
Size comparison excludes protocol headers and decoding cost. Compression is not encryption; no data was transmitted.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference='Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$previous=$null
foreach($angle in @(0,25,50,75)) {
    $frame=@(Get-SpinningCubeFrame -Degrees $angle)
    $text=$frame -join "`n"
    if($frame.Count -ne 21 -or @($frame | Where-Object Length -ne 45).Count) { throw 'Frame dimensions failed.' }
    if([regex]::Matches($text,'o').Count -ne 8 -or $text -notmatch '\+') { throw 'Vertex or edge count failed.' }
    if($previous -ceq $text) { throw 'Cube did not turn.' }
    "Cube angle: $angle degrees"
    $frame
    ''
    $previous=$text
}
$first=@(Get-SpinningCubeFrame -Degrees 0) -join "`n"
if($first -cne (@(Get-SpinningCubeFrame -Degrees 0) -join "`n")) { throw 'Replay changed.' }
if($first -cne (@(Get-SpinningCubeFrame -Degrees 360) -join "`n")) { throw 'Full turn did not return home.' }
'Checks passed: four bounded 45-by-21 frames, eight visible corners each, connected edge pixels, changing projection, deterministic replay, full-turn repeat.'
'Wireframe toy: rear edges remain visible. No delays, screen clearing, or terminal control sequences.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Project a rotating wireframe cube onto a bounded text canvas.
function Get-SpinningCubeFrame {
    [CmdletBinding()]
    param([ValidateRange(0,360)][double] $Degrees=0)
    $width=45; $height=21
    $grid=[char[,]]::new($height,$width)
    for($y=0;$y -lt $height;$y++) { for($x=0;$x -lt $width;$x++) { $grid[$y,$x]=' ' } }
    # Eight corners and twelve edges describe one cube; no hidden surface removal is attempted.
    $vertices=@(@(-1,-1,-1),@(1,-1,-1),@(1,1,-1),@(-1,1,-1),@(-1,-1,1),@(1,-1,1),@(1,1,1),@(-1,1,1))
    $edges=@(@(0,1),@(1,2),@(2,3),@(3,0),@(4,5),@(5,6),@(6,7),@(7,4),@(0,4),@(1,5),@(2,6),@(3,7))
    $angle=$Degrees*[math]::PI/180
    $points=@(foreach($v in $vertices) {
        # Rotate about the Y axis, tilt about X, then apply a simple perspective divide.
        $rx=$v[0]*[math]::Cos($angle)+$v[2]*[math]::Sin($angle)
        $rz=-$v[0]*[math]::Sin($angle)+$v[2]*[math]::Cos($angle)
        $ry=$v[1]*[math]::Cos(0.45)-$rz*[math]::Sin(0.45)
        $depth=$v[1]*[math]::Sin(0.45)+$rz*[math]::Cos(0.45)+5
        [pscustomobject]@{X=[int][math]::Round(22+40*$rx/$depth);Y=[int][math]::Round(10+20*$ry/$depth)}
    })
    # Rasterize each edge with bounded interpolation; vertical scale compensates for character shape.
    foreach($edge in $edges) {
        $a=$points[$edge[0]]; $b=$points[$edge[1]]
        $steps=[math]::Max([math]::Abs($b.X-$a.X),[math]::Abs($b.Y-$a.Y))
        for($i=0;$i -le $steps;$i++) {
            $t=if($steps) { $i/$steps } else { 0 }
            $x=[int][math]::Round($a.X+($b.X-$a.X)*$t)
            $y=[int][math]::Round($a.Y+($b.Y-$a.Y)*$t)
            if($x -ge 0 -and $x -lt $width -and $y -ge 0 -and $y -lt $height) { $grid[$y,$x]='+' }
        }
    }
    # Draw vertices last and emit ordinary lines that survive output redirection.
    foreach($point in $points) { $grid[$point.Y,$point.X]='o' }
    for($y=0;$y -lt $height;$y++) {
        $line=[char[]]::new($width)
        for($x=0;$x -lt $width;$x++) { $line[$x]=$grid[$y,$x] }
        -join $line
    }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
Cube angle: 0 degrees
                                             
                                             
                                             
                                             
                                             
               o+++++++++++++o               
            ++++             ++++            
           o+++++++++++++++++++++o           
           +    +           +    +           
           +    +           +    +           
            +   +           +   +            
            +   o+++++++++++o   +            
            +  +             +  +            
            +  +             +  +            
             ++               ++             
             ++               ++             
             o+++++++++++++++++o             
                                             
                                             
                                             
                                             

Cube angle: 25 degrees
                                             
                                             
                                             
                                             
                                             
                 ++o++++++                   
            +++++  +      +++++++o           
         o++++++++++          ++ +           
         +         +++++++++o+  +            
          +        +        +   +            
          +        +        +   +            
          +       +o+++++   +  +             
          +    +++       ++++++o             
           + ++            +  +              
           o++             + +               
              +++++        + +               
                   ++++++  ++                
                         ++o                 
                                             
                                             
                                             

Cube angle: 50 degrees
                                             
                                             
                                             
                                             
                                             
                 ++++++o+++++                
          o++++++      +     ++++++o         
          +  ++++++    + +++++++   +         
           +       ++o+++         +          
           +         + +          +          
           +         + +          +          
           +         ++o+         +          
            +  +++++++   ++++     +          
            o++      +       +++ +           
              ++     +         ++o           
                ++   +      +++              
                  ++ + +++++                 
                    +o+                      
                                             
                                             
                                             

Cube angle: 75 degrees
                                             
                                             
                                             
                                             
                                             
             o+++++++++++++o+                
             +             + ++++            
             ++          +++++++++o          
             +o++++++++++ +       +          
              +           +       +          
              +           +      +           
              +      +++++o      +           
              o++++++      ++    +           
              ++             +  +            
              ++              +++            
               +            ++++o            
               +    ++++++++                 
               o++++                         
                                             
                                             
                                             

Checks passed: four bounded 45-by-21 frames, eight visible corners each, connected edge pixels, changing projection, deterministic replay, full-turn repeat.
Wireframe toy: rear edges remain visible. No delays, screen clearing, or terminal control sequences.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
# Fictional, hand-authored answers test decision policy; these are not live Jev predictions.
function New-VenueFixture([double]$Quiet,[double]$Late,[double]$Transit) {
    [pscustomobject]@{answers=@{quiet=@{type='noul';noul=$Quiet};late=@{type='noul';noul=$Late};transit=@{type='noul';noul=$Transit}}}
}
$cases = @(
    Get-GameNightVenueDecision -Venue 'Maple Room' -Brief 'Quiet, open until 23:00, tram stop outside.' -Capacity 18 -Fixture (New-VenueFixture 0.95 0.93 0.9)
    Get-GameNightVenueDecision -Venue 'Music Loft' -Brief 'Loud music, late hours, near the station.' -Capacity 24 -Fixture (New-VenueFixture 0.1 0.98 0.97)
    Get-GameNightVenueDecision -Venue 'Canal Hall' -Brief 'Quiet, late hours; transit details unclear.' -Capacity 20 -Fixture (New-VenueFixture 0.92 0.91 0.55)
    Get-GameNightVenueDecision -Venue 'Tiny Nook' -Brief 'Lovely but small.' -Capacity 8
)
if (($cases.Outcome -join '|') -cne 'Shortlist only|Not a fit|Human review|Not a fit') { throw 'Multi-requirement policy failed.' }
$cases | Format-Table Venue,Mode,Outcome,Detail -Wrap
# Confirm exact band boundaries: 0.8 may shortlist, while 0.2 is a clear mismatch.
$boundary = Get-GameNightVenueDecision -Venue 'Boundary' -Brief 'test' -Capacity 12 -Fixture (New-VenueFixture 0.8 0.8 0.8)
if ($boundary.Outcome -ne 'Shortlist only') { throw 'Upper boundary failed.' }
$boundary = Get-GameNightVenueDecision -Venue 'Boundary' -Brief 'test' -Capacity 12 -Fixture (New-VenueFixture 0.2 0.9 0.9)
if ($boundary.Outcome -ne 'Not a fit') { throw 'Lower boundary failed.' }
# The module's generic keyword mock recognizes yes; this proves API wiring, not semantic skill.
$mock = Get-GameNightVenueDecision -Venue 'Mock contract' -Brief 'yes' -Capacity 12 -Mode Mock
if ($mock.Probabilities.quiet -ne 0.93 -or $mock.Outcome -ne 'Shortlist only') { throw 'Jev Mock contract failed.' }
"Current Jev Mock contract: $($mock.Outcome); quiet=$($mock.Probabilities.quiet)"
foreach ($bad in @($null,'0.9',[double]::NaN,[double]::PositiveInfinity,1.01,-0.1)) {
    $fixture = New-VenueFixture 0.9 0.9 0.9
    $fixture.answers.transit.noul = $bad
    $rejected = $false
    try { Get-GameNightVenueDecision -Venue 'Bad answer' -Brief 'test' -Capacity 12 -Fixture $fixture | Out-Null } catch { $rejected=$true }
    if (-not $rejected) { throw 'Malformed answer was accepted.' }
}
'Checks passed: all-of policy, one strong no, uncertainty review, hard seat gate, both thresholds, real Jev Mock, malformed-answer rejection.'
'Live API: not called. Authored fixtures and keyword Mock do not establish prediction accuracy or calibration.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Ask three independent Jev questions, then apply an all-requirements policy in ordinary PowerShell.
function Get-GameNightVenueDecision {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)][string] $Venue,
        [Parameter(Mandatory)][string] $Brief,
        [Parameter(Mandatory)][ValidateRange(1,200)][int] $Capacity,
        [ValidateRange(1,200)][int] $Guests = 12,
        [ValidateSet('Fixture','Mock')][string] $Mode = 'Fixture',
        [object] $Fixture
    )
    # Reject a hard numeric mismatch before any model decision; never reserve or contact a venue.
    if ($Capacity -lt $Guests) {
        return [pscustomobject]@{ Venue=$Venue; Mode='Numeric gate'; Outcome='Not a fit'; Detail='Not enough seats'; Probabilities=$null }
    }
    Import-Module Jev -MinimumVersion 0.4.0 -ErrorAction Stop
    $criteria = [ordered]@{
        quiet = 'A quiet room where a tabletop group can hear one another without loud music.'
        late = 'The space is available until at least 22:00 for the whole event.'
        transit = 'The supplied brief explicitly describes a nearby public transit stop.'
    }
    # Noul answers are independent yes probabilities, not competing Choice labels or scores.
    $questions = @(foreach ($entry in $criteria.GetEnumerator()) {
        New-JevYesNoQuestion -Name $entry.Key -Question "Does this venue meet this requirement: $($entry.Value)" `
            -TrueCriteria $entry.Value -FalseCriteria 'The brief contradicts or does not establish this requirement.'
    })
    # Fixtures are authored policy test inputs; Mock is the real module's offline keyword path.
    # There is intentionally no Live mode or credential lookup in this lab.
    $response = if ($Mode -eq 'Mock') {
        Invoke-Jev -State $Brief -Question $questions -Mock -Raw -ErrorAction Stop
    } else {
        if ($null -eq $Fixture) { throw 'Fixture mode requires a response with answers.' }
        $Fixture
    }
    $probabilities = [ordered]@{}
    foreach ($name in $criteria.Keys) {
        $answer = $response.answers.$name
        # Missing, nonnumeric, or out-of-range values must not become an implicit zero or approval.
        if ($null -eq $answer -or $answer.type -cne 'noul' -or $null -eq $answer.noul -or
            $answer.noul -is [string] -or $answer.noul -is [bool] -or $answer.noul -isnot [ValueType]) {
            throw "Invalid Noul answer for $name."
        }
        $p = [double]$answer.noul
        if ([double]::IsNaN($p) -or [double]::IsInfinity($p) -or $p -lt 0 -or $p -gt 1) { throw "Invalid probability for $name." }
        $probabilities[$name] = $p
    }
    # A high average cannot hide one missing requirement. The bands are example policy, not guarantees.
    $failed = @($probabilities.Keys | Where-Object { $probabilities[$_] -le 0.2 })
    $uncertain = @($probabilities.Keys | Where-Object { $probabilities[$_] -gt 0.2 -and $probabilities[$_] -lt 0.8 })
    $outcome = if ($failed.Count) { 'Not a fit' } elseif ($uncertain.Count) { 'Human review' } else { 'Shortlist only' }
    $detail = if ($failed.Count) { 'Fails: ' + ($failed -join ', ') } elseif ($uncertain.Count) { 'Unclear: ' + ($uncertain -join ', ') } else { 'All three requirements reach 0.8; confirm details before booking' }
    [pscustomobject]@{ Venue=$Venue; Mode=$Mode; Outcome=$outcome; Detail=$detail; Probabilities=[pscustomobject]$probabilities }
    # The result is a reviewable recommendation; no reservation, message, or action is dispatched.
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:

Venue      Mode         Outcome        Detail
-----      ----         -------        ------
Maple Room Fixture      Shortlist only All three requirements reach 0.8; confir
                                       m details before booking
Music Loft Fixture      Not a fit      Fails: quiet
Canal Hall Fixture      Human review   Unclear: transit
Tiny Nook  Numeric gate Not a fit      Not enough seats

Current Jev Mock contract: Shortlist only; quiet=0.93
Checks passed: all-of policy, one strong no, uncertainty review, hard seat gate, both thresholds, real Jev Mock, malformed-answer rejection.
Live API: not called. Authored fixtures and keyword Mock do not establish prediction accuracy or calibration.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$destination = Join-Path ([IO.Path]::GetTempPath()) ('kite-kits-'+[guid]::NewGuid().ToString('N')+'.xlsx')
$result = Export-KiteKitWorkbook -Path $destination -TargetKits 20
# Reopen the saved workbook to verify persisted data, formulas, and formatting rules.
$package = Open-ExcelPackage -Path $result.Path
try {
    $parts = $package.Workbook.Worksheets['Parts']
    $summary = $package.Workbook.Worksheets['Summary']
    if ($package.Workbook.Worksheets.Count -ne 2 -or $parts.Dimension.End.Row -ne 6) { throw 'Workbook layout failed.' }
    if ([double]$summary.Cells['B3'].Value -ne 15 -or [math]::Abs([double]$summary.Cells['B4'].Value-2.7) -gt 0.0001) { throw 'Saved totals failed.' }
    $formulaCount=0
    foreach ($cell in $parts.Cells['E2:H6']) { if ($cell.Formula) { $formulaCount++ } }
    foreach ($cell in $summary.Cells['B3:B4']) { if ($cell.Formula) { $formulaCount++ } }
    if ($formulaCount -ne 22 -or $parts.ConditionalFormatting.Count -ne 2) { throw 'Formula/format contract failed.' }
    'Target: 20 kite kits | Complete kits now: 15'
    'Bottleneck: Tail ribbons (45 on hand / 3 per kit)'
    'Buy 15 tail ribbons and 2 string spools | Restock cost: 2.70 sample currency units'
    # Editing an input and recalculating in memory proves formulas are not pasted constants.
    $parts.Cells['B4'].Value=60
    [OfficeOpenXml.CalculationExtension]::Calculate($package.Workbook)
    if ([double]$summary.Cells['B3'].Value -ne 18 -or [math]::Abs([double]$summary.Cells['B4'].Value-1.2) -gt 0.0001) { throw 'Edited-stock scenario failed.' }
    'What-if: add 15 ribbons -> 18 complete kits; string spools become the bottleneck.'
    # This what-if is not saved, so the generated workbook retains the original scenario.
} finally { $package.Dispose() }
$rejected=$false
try { Export-KiteKitWorkbook -Path $destination | Out-Null } catch { $rejected=$true }
if (-not $rejected) { throw 'Existing workbook overwrite was allowed.' }
'Checks passed: saved XLSX, two sheets, five parts, 22 formulas, two formatting rules, cached totals, editable what-if, overwrite rejection.'
'Workbook retained at a unique temporary path. No Excel desktop, network, or deletion used.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Create a new workbook that exposes the stock item limiting a fictional kite-making workshop.
function Export-KiteKitWorkbook {
    [CmdletBinding()]
    param([Parameter(Mandatory)][string] $Path, [ValidateRange(1,100)][int] $TargetKits = 20)
    Import-Module ImportExcel -MinimumVersion 7.8.10 -ErrorAction Stop
    # Never overwrite an existing workbook; the runner supplies a unique temporary filename.
    if (Test-Path -LiteralPath $Path) { throw 'Choose a new workbook path; existing files are not overwritten.' }
    $parts = @(
        [pscustomobject]@{Part='Bamboo spars'; OnHand=52; PerKit=2; UnitCost=0.45},
        [pscustomobject]@{Part='Paper sails'; OnHand=24; PerKit=1; UnitCost=0.8},
        [pscustomobject]@{Part='Tail ribbons'; OnHand=45; PerKit=3; UnitCost=0.1},
        [pscustomobject]@{Part='String spools'; OnHand=18; PerKit=1; UnitCost=0.6},
        [pscustomobject]@{Part='Connector clips'; OnHand=100; PerKit=4; UnitCost=0.05}
    )
    # All calculations remain inspectable Excel formulas and can respond to edited stock counts.
    $rows = foreach ($part in $parts) {
        [pscustomobject][ordered]@{Part=$part.Part; OnHand=$part.OnHand; PerKit=$part.PerKit; UnitCost=$part.UnitCost; KitsPossible=0; NeedForTarget=0; BuyUnits=0; BuyCost=0}
    }
    $package = $rows | Export-Excel -Path $Path -WorksheetName Parts -TableName KiteParts -BoldTopRow -FreezeTopRow -PassThru
    try {
        $sheet = $package.Workbook.Worksheets['Parts']
        $sheet.Column(1).Width = 24
        foreach ($column in 2..8) { $sheet.Column($column).Width = 17 }
        for ($row=2; $row -le 6; $row++) {
            # Integer floor gives complete kits; MAX prevents negative shopping quantities.
            $sheet.Cells[$row,5].Formula = "INT(B$row/C$row)"
            $sheet.Cells[$row,6].Formula = "C$row*Summary!B2"
            $sheet.Cells[$row,7].Formula = "MAX(F$row-B$row,0)"
            $sheet.Cells[$row,8].Formula = "G$row*D$row"
        }
        $sheet.Cells['D2:D6'].Style.Numberformat.Format = '0.00'
        $sheet.Cells['H2:H6'].Style.Numberformat.Format = '0.00'
        # Data bars reveal low complete-kit capacity; a rule highlights actual purchase needs.
        Add-ConditionalFormatting -Worksheet $sheet -Address 'E2:E6' -DataBarColor Blue | Out-Null
        Add-ConditionalFormatting -Worksheet $sheet -Address 'G2:G6' -RuleType GreaterThan -ConditionValue 0 -BackgroundColor LightYellow | Out-Null
        $summary = Add-Worksheet -ExcelPackage $package -WorksheetName Summary
        $summary.Cells['A1'].Value='Kite workshop'; $summary.Cells['A1:B1'].Style.Font.Bold=$true
        $summary.Cells['A2'].Value='Target kits'; $summary.Cells['B2'].Value=$TargetKits
        $summary.Cells['A3'].Value='Complete kits now'; $summary.Cells['B3'].Formula='MIN(Parts!E2:E6)'
        $summary.Cells['A4'].Value='Restock cost'; $summary.Cells['B4'].Formula='SUM(Parts!H2:H6)'
        $summary.Cells['B4'].Style.Numberformat.Format='0.00'
        $summary.Column(1).Width=27; $summary.Column(2).Width=18
        # Calculate and save cached values in the cloud; Excel itself is not required.
        [OfficeOpenXml.CalculationExtension]::Calculate($package.Workbook)
        $package.Save()
    } finally {
        $package.Dispose()
    }
    # Return the new artifact path without opening a desktop application.
    [pscustomobject]@{Path=$Path; TargetKits=$TargetKits; Parts=$parts.Count}
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
WARNING: ImportExcel Module Cannot Autosize. Please run the following command to install dependencies:
apt-get -y update && apt-get install -y --no-install-recommends libgdiplus libc6-dev
Target: 20 kite kits | Complete kits now: 15
Bottleneck: Tail ribbons (45 on hand / 3 per kit)
Buy 15 tail ribbons and 2 string spools | Restock cost: 2.70 sample currency units
What-if: add 15 ribbons -> 18 complete kits; string spools become the bottleneck.
Checks passed: saved XLSX, two sheets, five parts, 22 formulas, two formatting rules, cached totals, editable what-if, overwrite rejection.
Workbook retained at a unique temporary path. No Excel desktop, network, or deletion used.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
# Fictional guests include textual identifiers that must not become numbers.
$guests = @(
    [pscustomobject]@{GuestId='007'; Name='Mira'},
    [pscustomobject]@{GuestId='B2'; Name='Rowan'},
    [pscustomobject]@{GuestId='7'; Name='Kit'}
)
$bookings = @(
    [pscustomobject]@{GuestId='007'; Session='Paper circuits'},
    [pscustomobject]@{GuestId=' 007 '; Session='Kite making'},
    [pscustomobject]@{GuestId='b2'; Session='Clay creatures'},
    [pscustomobject]@{GuestId='X9'; Session='Unmatched guest'}
)
$before = ConvertTo-Json -InputObject @($guests,$bookings) -Depth 5 -Compress
$rows = @(Join-WorkshopBooking -Guests $guests -Bookings $bookings)
if ($rows.Count -ne 4 -or @($rows | Where-Object GuestId -eq '007').Count -ne 2) { throw 'A booking was lost.' }
if ($rows[2].Session -ne 'Clay creatures' -or $rows[3].Match -ne 'No booking') { throw 'Join policy failed.' }
if ($rows[3].GuestId -cne '7' -or $rows[0].GuestId -cne '007') { throw 'Text identifiers changed.' }
if ($before -cne (ConvertTo-Json -InputObject @($guests,$bookings) -Depth 5 -Compress)) { throw 'Input mutated.' }
$rows | Format-Table GuestId,Name,Session,Match -AutoSize
$known = @($guests | ForEach-Object { ([string]$_.GuestId).Trim() })
$orphans = @($bookings | Where-Object { ([string]$_.GuestId).Trim() -notin $known })
"Orphan bookings held separately: $($orphans.Count)"
if ($orphans.Count -ne 1) { throw 'Orphan count failed.' }
if (@(Join-WorkshopBooking -Guests @() -Bookings @()).Count -ne 0) { throw 'Empty join failed.' }
$duplicate = $false
try { Join-WorkshopBooking -Guests @($guests[0],$guests[0]) -Bookings @() | Out-Null } catch { $duplicate = $true }
if (-not $duplicate) { throw 'Duplicate guest keys accepted.' }
$blank = $false
try { Join-WorkshopBooking -Guests $guests -Bookings @([pscustomobject]@{GuestId=' ';Session='test'}) | Out-Null } catch { $blank = $true }
if (-not $blank) { throw 'Blank key accepted.' }
'Checks passed: both matches, left join, orphan count, case/space policy, leading zeroes, empty input, duplicate/blank rejection, unchanged inputs.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Join one guest to zero or many bookings without overwriting repeated right-side keys.
function Join-WorkshopBooking {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)][AllowEmptyCollection()][object[]] $Guests,
        [Parameter(Mandatory)][AllowEmptyCollection()][object[]] $Bookings
    )
    # Trim padding and ignore letter case, but preserve leading zeroes as text.
    $guestKeys = [System.Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
    $index = [System.Collections.Generic.Dictionary[string,object]]::new([StringComparer]::OrdinalIgnoreCase)
    foreach ($guest in $Guests) {
        $key = ([string]$guest.GuestId).Trim()
        if (-not $key -or -not $guestKeys.Add($key)) { throw 'Guest IDs must be nonblank and unique after normalization.' }
    }
    # Each dictionary value is a list, not a single booking that the next row replaces.
    foreach ($booking in $Bookings) {
        $key = ([string]$booking.GuestId).Trim()
        if (-not $key) { throw 'Booking GuestId cannot be blank.' }
        if (-not $index.ContainsKey($key)) { $index.Add($key, [System.Collections.Generic.List[object]]::new()) }
        $index[$key].Add($booking)
    }
    # Preserve guest order, then booking order within each guest; emit an explicit unmatched row.
    foreach ($guest in $Guests) {
        $key = ([string]$guest.GuestId).Trim()
        if ($index.ContainsKey($key)) {
            foreach ($booking in $index[$key]) {
                [pscustomobject]@{ GuestId = $guest.GuestId; Name = $guest.Name; Session = $booking.Session; Match = 'Booked' }
            }
        } else {
            [pscustomobject]@{ GuestId = $guest.GuestId; Name = $guest.Name; Session = $null; Match = 'No booking' }
        }
    }
    # This is a left join: bookings whose guest is absent do not invent a new guest.
    # Original objects remain untouched; callers can separately report orphan bookings.
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:

GuestId Name  Session        Match
------- ----  -------        -----
007     Mira  Paper circuits Booked
007     Mira  Kite making    Booked
B2      Rowan Clay creatures Booked
7       Kit                  No booking

Orphan bookings held separately: 1
Checks passed: both matches, left join, orphan count, case/space policy, leading zeroes, empty input, duplicate/blank rejection, unchanged inputs.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$target = 'Make small things work well.'
$rounds = @(
    [pscustomobject]@{Name='Steady'; Text=$target; Seconds=15},
    [pscustomobject]@{Name='Rushed'; Text='Meke smoll thongs wark wall.'; Seconds=14},
    [pscustomobject]@{Name='Blank'; Text=''; Seconds=15}
)
$results = @($rounds | ForEach-Object {
    $score = Measure-TypingReplay -Expected $target -Typed $_.Text -Seconds $_.Seconds
    [pscustomobject]@{Round=$_.Name; GrossWpm=$score.GrossWpm; Edits=$score.EditDistance; AccuracyPct=$score.AccuracyPct; AdjustedWpm=$score.AccuracyAdjustedWpm}
})
if ($results[0].Edits -ne 0 -or $results[0].AccuracyPct -ne 100) { throw 'Exact match failed.' }
if ($results[1].GrossWpm -le $results[0].GrossWpm -or $results[1].AdjustedWpm -ge $results[0].AdjustedWpm) { throw 'Speed/accuracy tradeoff not demonstrated.' }
if ($results[2].AccuracyPct -ne 0 -or $results[2].AdjustedWpm -ne 0) { throw 'Empty text failed.' }
$results | Format-Table -AutoSize
# Probe each edit operation and case sensitivity without timing real typing.
foreach ($case in @(@('cat','cart'),@('cat','ct'),@('cat','cut'),@('cat','Cat'))) {
    if ((Measure-TypingReplay -Expected $case[0] -Typed $case[1] -Seconds 10).EditDistance -ne 1) { throw 'Edit operation failed.' }
}
$rejected = $false
try { Measure-TypingReplay -Expected 'cat' -Typed 'cat' -Seconds 0 | Out-Null } catch { $rejected = $true }
if (-not $rejected) { throw 'Zero duration accepted.' }
'Checks passed: exact match, insertion, deletion, substitution, case sensitivity, blank replay, zero-time rejection, faster-but-less-accurate comparison.'
'Metrics use final text, UTF-16 code units, and five characters per word; corrected keystrokes are not measured.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Compare completed practice text; never capture keystrokes or wait for a person.
function Measure-TypingReplay {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)][ValidateLength(1,200)][string] $Expected,
        [Parameter(Mandatory)][AllowEmptyString()][ValidateLength(0,200)][string] $Typed,
        [Parameter(Mandatory)][ValidateRange(0.1,3600)][double] $Seconds
    )
    # This small edit-distance calculation counts insertions, deletions, and substitutions.
    # Two rows bound storage; ordinal UTF-16 comparison is case and punctuation sensitive.
    $previous = [int[]](0..$Typed.Length)
    for ($i = 1; $i -le $Expected.Length; $i++) {
        $current = [int[]]::new($Typed.Length + 1)
        $current[0] = $i
        for ($j = 1; $j -le $Typed.Length; $j++) {
            $cost = if ($Expected[$i-1] -ceq $Typed[$j-1]) { 0 } else { 1 }
            $current[$j] = [math]::Min([math]::Min($previous[$j]+1, $current[$j-1]+1), $previous[$j-1]+$cost)
        }
        $previous = $current
    }
    # Use the five-character word convention and show an explicit normalized accuracy metric.
    # These are final-text measurements, not a record of corrected mistakes or backspaces.
    $distance = $previous[$Typed.Length]
    $denominator = [math]::Max($Expected.Length,$Typed.Length)
    $accuracy = 1 - $distance / $denominator
    [pscustomobject]@{
        Seconds = $Seconds
        GrossWpm = [math]::Round(($Typed.Length / 5) * 60 / $Seconds, 2)
        EditDistance = $distance
        AccuracyPct = [math]::Round(100 * $accuracy, 2)
        AccuracyAdjustedWpm = [math]::Round(($Typed.Length / 5) * 60 / $Seconds * $accuracy, 2)
    }
    # Accuracy-adjusted WPM is this lab's comparison metric, not an official typing-test score.
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:

Round  GrossWpm Edits AccuracyPct AdjustedWpm
-----  -------- ----- ----------- -----------
Steady    22.40     0      100.00       22.40
Rushed    24.00     5       82.14       19.71
Blank      0.00    28        0.00        0.00

Checks passed: exact match, insertion, deletion, substitution, case sensitivity, blank replay, zero-time rejection, faster-but-less-accurate comparison.
Metrics use final text, UTF-16 code units, and five characters per word; corrected keystrokes are not measured.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
foreach ($tick in @(0,2,4,6)) {
    $frame = @(Get-PocketOrbitFrame -Tick $tick)
    if ($frame.Count -ne 19 -or @($frame | Where-Object Length -ne 43).Count) { throw 'Canvas dimensions changed.' }
    $text = $frame -join "`n"
    foreach ($mark in @('*','1','2','3')) {
        if ([regex]::Matches($text,[regex]::Escape($mark)).Count -ne 1) { throw "Marker count failed: $mark" }
    }
    "Tick $tick | star * | planets 1 2 3"
    $frame
    ''
}
$first = @(Get-PocketOrbitFrame -Tick 0) -join "`n"
if ($first -cne (@(Get-PocketOrbitFrame -Tick 0) -join "`n")) { throw 'Frame is not deterministic.' }
if ($first -cne (@(Get-PocketOrbitFrame -Tick 32) -join "`n")) { throw 'Full orbital cycle did not repeat.' }
if ($first -ceq (@(Get-PocketOrbitFrame -Tick 2) -join "`n")) { throw 'Planets did not move.' }
'Checks passed: four bounded frames, fixed canvas, one of each marker, deterministic replay, motion, 32-tick cycle.'
'Toy circular orbits and invented periods; not a real sky map. No waits or terminal escape sequences.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Render a toy orbital clock as bounded text frames, without animation delays or terminal control codes.
function Get-PocketOrbitFrame {
    [CmdletBinding()]
    param([ValidateRange(0,48)][int] $Tick = 0)
    # A fixed rectangular canvas compresses vertical distance for terminal character proportions.
    $width = 43; $height = 19; $cx = 21; $cy = 9
    $grid = [char[,]]::new($height,$width)
    for ($y=0; $y -lt $height; $y++) { for ($x=0; $x -lt $width; $x++) { $grid[$y,$x] = ' ' } }
    $planets = @(
        @{Mark='1'; Radius=6; Period=8; Phase=0},
        @{Mark='2'; Radius=12; Period=16; Phase=1.1},
        @{Mark='3'; Radius=18; Period=32; Phase=2.3}
    )
    # Paint orbit guides first, so planet markers always win when a cell is shared.
    foreach ($planet in $planets) {
        for ($step=0; $step -lt 96; $step++) {
            $angle = 2 * [math]::PI * $step / 96
            $x = [int][math]::Round($cx + $planet.Radius * [math]::Cos($angle))
            $y = [int][math]::Round($cy + $planet.Radius * 0.42 * [math]::Sin($angle))
            $grid[$y,$x] = '.'
        }
    }
    # Circular paths and invented periods make a visual toy, not an astronomical prediction.
    foreach ($planet in $planets) {
        $angle = $planet.Phase + 2 * [math]::PI * $Tick / $planet.Period
        $x = [int][math]::Round($cx + $planet.Radius * [math]::Cos($angle))
        $y = [int][math]::Round($cy + $planet.Radius * 0.42 * [math]::Sin($angle))
        $grid[$y,$x] = [char]$planet.Mark
    }
    $grid[$cy,$cx] = '*'
    # Return ordinary strings at a fixed width so redirected output is reproducible.
    for ($y=0; $y -lt $height; $y++) {
        $line = [char[]]::new($width)
        for ($x=0; $x -lt $width; $x++) { $line[$x] = $grid[$y,$x] }
        -join $line
    }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
Tick 0 | star * | planets 1 2 3
                                           
                    ...                    
            ...... .   . ......            
         ...                   ...         
       ..       ...........       ..       
     ..      ...           ...      ..     
    ..     ..        .        ..     ..    
    .     .     ..... .....     .     .    
   .     .     ..         ..     .     .   
   .     .     .     *     1     .     .   
   .     .     ..         ..     .     .   
    .     .     ..... .....     .     .    
    ..     ..        .        ..     ..    
     ..      ...          2...      ..     
       ..       ...........       ..       
         3..                   ...         
            ...... .   . ......            
                    ...                    
                                           

Tick 2 | star * | planets 1 2 3
                                           
                    ...                    
            ...... .   . ......            
         ...                   ...         
       ..       ...........       ..       
     ..      ...           ...      ..     
    ..     ..        .        ..     ..    
    .     .     ..... .....     .     .    
   .     .     ..         ..     .     .   
   .     .     .     *     .     .     .   
   .     .     ..         ..     .     .   
    .     .     ..... .....     .     .    
    .3     ..        1        ..     ..    
     ..      ...           ...      ..     
       ..       .2.........       ..       
         ...                   ...         
            ...... .   . ......            
                    ...                    
                                           

Tick 4 | star * | planets 1 2 3
                                           
                    ...                    
            ...... .   . ......            
         ...                   ...         
       ..       ...........       ..       
     ..      ...           ...      ..     
    ..     ..        .        ..     ..    
    .     .     ..... .....     .     .    
   .     .     ..         ..     .     .   
   3     .     1     *     .     .     .   
   .     .     ..         ..     .     .   
    .     2     ..... .....     .     .    
    ..     ..        .        ..     ..    
     ..      ...           ...      ..     
       ..       ...........       ..       
         ...                   ...         
            ...... .   . ......            
                    ...                    
                                           

Tick 6 | star * | planets 1 2 3
                                           
                    ...                    
            ...... .   . ......            
         ...                   ...         
       ..       ...........       ..       
     ..      ...           ...      ..     
    ..     ..        1        ..     ..    
    3     2     ..... .....     .     .    
   .     .     ..         ..     .     .   
   .     .     .     *     .     .     .   
   .     .     ..         ..     .     .   
    .     .     ..... .....     .     .    
    ..     ..        .        ..     ..    
     ..      ...           ...      ..     
       ..       ...........       ..       
         ...                   ...         
            ...... .   . ......            
                    ...                    
                                           

Checks passed: four bounded frames, fixed canvas, one of each marker, deterministic replay, motion, 32-tick cycle.
Toy circular orbits and invented periods; not a real sky map. No waits or terminal escape sequences.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
# These authored fixture distributions exercise policy, not model accuracy.
$strong = [pscustomobject]@{ answers = @{ nextScene = @{ type = 'choice'; choice = 'bridge'; probabilities = @{ bridge = 0.92; lantern = 0.05; shelter = 0.03 } } } }
$uncertain = [pscustomobject]@{ answers = @{ nextScene = @{ type = 'choice'; choice = 'lantern'; probabilities = @{ bridge = 0.28; lantern = 0.55; shelter = 0.17 } } } }
$a = Get-StoryBranch -State 'A river blocks the path.' -Fixture $strong
$b = Get-StoryBranch -State 'A dark passage may lead outside.' -Fixture $uncertain
# The literal word shelter is deliberately chosen for the module's keyword mock.
$c = Get-StoryBranch -State 'The traveler needs shelter from the storm.' -Mode Mock
if ($a.Action -ne 'Continue' -or $b.Action -ne 'Ask the storyteller' -or $c.Suggested -ne 'shelter') { throw 'Branch policy failed.' }
foreach ($row in @($a, $b, $c)) {
    '{0}: {1} p={2:F2} -> {3}' -f $row.Mode, $row.Suggested, $row.Probability, $row.Action
    $row.Scene
}
# Malformed answers must stop rather than dispatch an unknown scene.
$invalid = [pscustomobject]@{ answers = @{ nextScene = @{ type = 'choice'; choice = 'run-code'; probabilities = @{ 'run-code' = 1.0 } } } }
$rejected = $false
try { Get-StoryBranch -State 'test' -Fixture $invalid | Out-Null } catch { $rejected = $true }
if (-not $rejected) { throw 'Unknown scene was accepted.' }
$invalid.answers.nextScene.choice = 'bridge'
$invalid.answers.nextScene.probabilities = @{ bridge = [double]::NaN }
$rejected = $false
try { Get-StoryBranch -State 'test' -Fixture $invalid | Out-Null } catch { $rejected = $true }
if (-not $rejected) { throw 'NaN probability was accepted.' }
'Checks passed: confident branch, human pause, current Jev Mock, unknown scene and NaN rejection.'
'Live API: not called. Fixtures and Mock do not measure prediction quality.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Turn a bounded Jev Choice into a known story card; returned text is never executed.
function Get-StoryBranch {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)][string] $State,
        [ValidateSet('Fixture', 'Mock')][string] $Mode = 'Fixture',
        [object] $Fixture,
        [ValidateRange(0.5, 1.0)][double] $Threshold = 0.8
    )
    # Use the current Jev question builder even when the decision is an authored fixture.
    Import-Module Jev -MinimumVersion 0.4.0 -ErrorAction Stop
    $scenes = [ordered]@{
        lantern = 'Light a lantern to explore the dark passage.'
        bridge  = 'Cross the river using the old rope bridge.'
        shelter = 'Wait out the storm in the stone shelter.'
    }
    $question = New-JevQuestion -Name nextScene -Type Choice `
        -Instructions 'Which scene best fits the current story state?' -Criteria $scenes
    # Mock is the real module's local deterministic implementation, not a live API answer.
    $response = if ($Mode -eq 'Mock') {
        Invoke-Jev -State $State -Question $question -Raw -Mock -ErrorAction Stop
    } else { $Fixture }
    # Validate the answer before using it as a dictionary key.
    $answer = $response.answers.nextScene
    if ($null -eq $answer -or $answer.type -ne 'choice') { throw 'Missing Choice answer.' }
    $selected = [string] $answer.choice
    if (-not $scenes.Contains($selected)) { throw 'The answer selected an unknown scene.' }
    $probability = 0.0
    $raw = $answer.probabilities.$selected
    if ($null -eq $raw -or -not [double]::TryParse([string] $raw,
        [Globalization.NumberStyles]::Float, [Globalization.CultureInfo]::InvariantCulture,
        [ref] $probability) -or -not [double]::IsFinite($probability) -or
        $probability -lt 0 -or $probability -gt 1) { throw 'Invalid selected probability.' }
    # PowerShell owns the review policy and chooses only from the fixed scene table.
    $approved = $probability -ge $Threshold
    [pscustomobject]@{
        Mode = $Mode; Suggested = $selected; Probability = $probability
        Action = if ($approved) { 'Continue' } else { 'Ask the storyteller' }
        Scene = if ($approved) { $scenes[$selected] } else { 'Pause for a human choice.' }
    }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
Fixture: bridge p=0.92 -> Continue
Cross the river using the old rope bridge.
Fixture: lantern p=0.55 -> Ask the storyteller
Pause for a human choice.
Mock: shelter p=0.82 -> Continue
Wait out the storm in the stone shelter.
Checks passed: confident branch, human pause, current Jev Mock, unknown scene and NaN rejection.
Live API: not called. Fixtures and Mock do not measure prediction quality.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$menu = @(
    [pscustomobject]@{ Item = 'Cinnamon bun'; Category = 'Bakery'; Units = 40; Price = 3.5; Cost = 1.2 }
    [pscustomobject]@{ Item = 'Breakfast box'; Category = 'Kitchen'; Units = 60; Price = 4.0; Cost = 4.5 }
    [pscustomobject]@{ Item = 'Cold brew'; Category = 'Drinks'; Units = 35; Price = 4.0; Cost = 0.9 }
    [pscustomobject]@{ Item = 'Herb toast'; Category = 'Kitchen'; Units = 15; Price = 6.0; Cost = 2.4 }
    [pscustomobject]@{ Item = 'Unsold special'; Category = 'Kitchen'; Units = 0; Price = 0.0; Cost = 2.0 }
)
# A unique temporary output keeps the example repeatable without deleting or replacing files.
$path = Join-Path ([IO.Path]::GetTempPath()) ('cafe-margin-' + [guid]::NewGuid().ToString('N') + '.xlsx')
$result = New-CafeMarginWorkbook -Menu $menu -Path $path
$book = Open-ExcelPackage -Path $path
try {
    $sheet = $book.Workbook.Worksheets['Menu']
    if ($book.Workbook.Worksheets.Count -ne 2 -or $sheet.Dimension.Rows -ne 6) { throw 'Workbook shape failed.' }
    if ($sheet.Cells[3, 8].Value -ne -30 -or $sheet.Cells[6, 9].Value -ne 0) { throw 'Formula result failed.' }
    if ([math]::Abs($result.GrossProfit - 224.5) -gt 0.001) { throw 'Profit total failed.' }
    if ($sheet.ConditionalFormatting.Count -ne 1) { throw 'Loss highlighting missing.' }
    if ([string]::IsNullOrWhiteSpace($sheet.Cells[3, 8].Formula)) { throw 'Formula was lost.' }
    'Workbook reopened: 2 sheets, 5 menu items, 20 formulas, 1 loss rule.'
    'Best seller: Breakfast box | 60 sold | gross profit -30.00'
    'Total gross profit: 224.50 (before labor, rent, and other overhead).'
    'Checks passed: formulas preserved, totals, zero-revenue margin, loss highlight.'
} finally { $book.Dispose() }
'Output workbook remains in the temporary directory; nothing was deleted.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Build a menu workbook with editable inputs and calculated profit, without Excel.
function New-CafeMarginWorkbook {
    [CmdletBinding()]
    param([Parameter(Mandatory)][object[]] $Menu, [Parameter(Mandatory)][string] $Path)
    Import-Module ImportExcel -MinimumVersion 7.8.10 -ErrorAction Stop
    # Refuse an existing destination so reruns cannot overwrite someone's workbook.
    if (Test-Path -LiteralPath $Path) { throw 'Choose a new workbook path.' }
    foreach ($item in $Menu) {
        if ($item.Units -lt 0 -or $item.Price -lt 0 -or $item.Cost -lt 0) { throw 'Inputs must be non-negative.' }
    }
    # Fix column order so formulas stay readable and easy to inspect.
    $rows = @($Menu | ForEach-Object {
        [pscustomobject][ordered]@{
            Item = $_.Item; Category = $_.Category; Units = $_.Units
            Price = $_.Price; Cost = $_.Cost
            Revenue = 0; IngredientCost = 0; GrossProfit = 0; Margin = 0
        }
    })
    $package = $rows | Export-Excel -Path $Path -WorksheetName Menu -TableName MenuMargin `
        -TableStyle Medium2 -BoldTopRow -FreezeTopRow -PassThru
    try {
        $sheet = $package.Workbook.Worksheets['Menu']
        # Use spreadsheet formulas so changing units, price, or cost updates the comparison.
        for ($row = 2; $row -le $rows.Count + 1; $row++) {
            $sheet.Cells[$row, 6].Formula = "C$row*D$row"
            $sheet.Cells[$row, 7].Formula = "C$row*E$row"
            $sheet.Cells[$row, 8].Formula = "F$row-G$row"
            $sheet.Cells[$row, 9].Formula = "IF(F$row=0,0,H$row/F$row)"
        }
        # Set explicit widths; this needs no optional graphics/autofit dependency.
        $sheet.Column(1).Width = 25
        $sheet.Column(2).Width = 17
        foreach ($column in 3..9) { $sheet.Column($column).Width = 16 }
        $sheet.Cells["D2:H$($rows.Count + 1)"].Style.Numberformat.Format = '0.00'
        $sheet.Cells["I2:I$($rows.Count + 1)"].Style.Numberformat.Format = '0.0%'
        Add-ConditionalFormatting -Worksheet $sheet -Address "H2:H$($rows.Count + 1)" `
            -RuleType LessThan -ConditionValue 0 -BackgroundColor Red
        # Calculate inside the package, then aggregate the actual calculated cells by category.
        [OfficeOpenXml.CalculationExtension]::Calculate($package.Workbook)
        $totals = @{}
        for ($row = 2; $row -le $rows.Count + 1; $row++) {
            $category = [string] $sheet.Cells[$row, 2].Value
            if (-not $totals.ContainsKey($category)) { $totals[$category] = 0.0 }
            $totals[$category] += [double] $sheet.Cells[$row, 8].Value
        }
        $summary = $package.Workbook.Worksheets.Add('Category Profit')
        $summary.Cells[1, 1].Value = 'Category'
        $summary.Cells[1, 2].Value = 'GrossProfit'
        $row = 2
        foreach ($category in @($totals.Keys | Sort-Object)) {
            $summary.Cells[$row, 1].Value = $category
            $summary.Cells[$row, 2].Value = $totals[$category]
            $row++
        }
        $summary.Column(1).Width = 22
        $summary.Column(2).Width = 18
        $summary.Cells[1, 1, 1, 2].Style.Font.Bold = $true
        # Save once and always release the package handle.
        $package.Save()
        [pscustomobject]@{ Items = $rows.Count; Categories = $totals.Count; GrossProfit = ($totals.Values | Measure-Object -Sum).Sum }
    } finally { $package.Dispose() }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
WARNING: ImportExcel Module Cannot Autosize. Please run the following command to install dependencies:
apt-get -y update && apt-get install -y --no-install-recommends libgdiplus libc6-dev
Workbook reopened: 2 sheets, 5 menu items, 20 formulas, 1 loss rule.
Best seller: Breakfast box | 60 sold | gross profit -30.00
Total gross profit: 224.50 (before labor, rent, and other overhead).
Checks passed: formulas preserved, totals, zero-revenue margin, loss highlight.
Output workbook remains in the temporary directory; nothing was deleted.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$samples = @(
    [pscustomobject][ordered]@{ Item = 'Map'; Color = 'Blue' }
    [pscustomobject][ordered]@{ ITEM = 'Lamp'; Watts = 12 }
    [pscustomobject][ordered]@{ Item = 'Card, folded'; Note = "Line one`nLine two" }
)
$csv = @(ConvertTo-CompleteCsv -Record $samples)
$restored = @($csv | ConvertFrom-Csv)
$headers = @($restored[0].PSObject.Properties.Name)
if (($headers -join ',') -ne 'Item,Color,Watts,Note') { throw 'Union or header order failed.' }
if ($restored.Count -ne 3 -or $restored[1].Watts -ne '12' -or $restored[2].Note -ne $samples[2].Note) { throw 'Round trip failed.' }
if (($samples[0].PSObject.Properties.Name -join ',') -ne 'Item,Color') { throw 'Input was modified.' }
if (@(ConvertTo-CompleteCsv -Record @()).Count -ne 0) { throw 'Empty input failed.' }
$rejected = $false
try { ConvertTo-CompleteCsv -Record @([pscustomobject]@{ Nested = @(1, 2) }) | Out-Null } catch { $rejected = $true }
if (-not $rejected) { throw 'Nested values were silently accepted.' }
'Columns: ' + ($headers -join ', ')
'Rows: 3 | later-only Watts=12 preserved | multiline Note preserved'
$csv
'Checks passed: column union, case variants, blanks, quoting, empty input, nested-value rejection.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Normalize a finite set of flat objects before converting it to CSV in memory.
function ConvertTo-CompleteCsv {
    [CmdletBinding()]
    param([Parameter(Mandatory)][AllowEmptyCollection()][object[]] $Record)
    if ($Record.Count -eq 0) { return }
    # Discover the union of names in first-seen order, ignoring case consistently with PowerShell.
    $seen = [Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
    $columns = [Collections.Generic.List[string]]::new()
    foreach ($item in $Record) {
        if ($null -eq $item -or $item -isnot [pscustomobject]) { throw 'Supply flat PSCustomObject records.' }
        foreach ($property in $item.PSObject.Properties) {
            if ($seen.Add($property.Name)) { $columns.Add($property.Name) }
            # Refuse nested values so callers cannot silently lose another layer in CSV.
            if ($null -ne $property.Value -and $property.Value -isnot [string] -and
                $property.Value -isnot [ValueType]) { throw 'Nested values need an explicit flattening policy.' }
        }
    }
    # Rebuild without modifying the inputs; missing values become blank CSV cells.
    $normalized = foreach ($item in $Record) {
        $row = [ordered]@{}
        foreach ($column in $columns) {
            $property = $item.PSObject.Properties[$column]
            $row[$column] = if ($null -eq $property) { $null } else { $property.Value }
        }
        [pscustomobject] $row
    }
    $normalized | ConvertTo-Csv -NoTypeInformation
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
Columns: Item, Color, Watts, Note
Rows: 3 | later-only Watts=12 preserved | multiline Note preserved
"Item","Color","Watts","Note"
"Map","Blue",,
"Lamp",,"12",
"Card, folded",,,"Line one
Line two"
Checks passed: column union, case variants, blanks, quoting, empty input, nested-value rejection.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$room = @(
    [pscustomobject]@{ Name = 'Mira'; X = 0; Y = 0 }
    [pscustomobject]@{ Name = 'Sol'; X = 3; Y = 0 }
    [pscustomobject]@{ Name = 'Tao'; X = 6; Y = 0 }
    [pscustomobject]@{ Name = 'Nia'; X = 12; Y = 2 }
)
$before = @(Get-NearbyConversation -People $room -Radius 3)
'Before the move:'
$before | ForEach-Object { '{0} | distance={1:F2}' -f $_.Pair, $_.Distance }
# Move only a fictional in-memory avatar, leaving the original snapshot intact.
$moved = @($room | ForEach-Object { [pscustomobject]@{ Name = $_.Name; X = $_.X; Y = $_.Y } })
$moved[3].X = 6
$moved[3].Y = 3
$after = @(Get-NearbyConversation -People $moved -Radius 3)
'After Nia walks closer:'
$after | ForEach-Object { '{0} | distance={1:F2}' -f $_.Pair, $_.Distance }
if ($before.Count -ne 2 -or $after.Count -ne 3 -or $after.Pair -notcontains 'Tao + Nia') { throw 'Proximity links failed.' }
if ($before.Pair -contains 'Mira + Tao' -or $room[3].X -ne 12) { throw 'Transitive shortcut or input mutation found.' }
'Checks passed: radius boundary, new link, no transitive shortcut, original snapshot preserved.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Find direct conversation links in a fictional two-dimensional room.
function Get-NearbyConversation {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)][object[]] $People,
        [ValidateRange(0.1, 100)][double] $Radius = 3
    )
    # Unique names make each reported pair unambiguous.
    $names = [Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
    foreach ($person in $People) {
        if ([string]::IsNullOrWhiteSpace($person.Name) -or -not $names.Add($person.Name)) { throw 'Names must be non-empty and unique.' }
        foreach ($value in @($person.X, $person.Y)) {
            if ($null -eq $value -or -not [double]::IsFinite([double] $value)) { throw 'Coordinates must be finite.' }
        }
    }
    # Inspect each unordered pair once; no transitive grouping is assumed.
    for ($left = 0; $left -lt $People.Count; $left++) {
        for ($right = $left + 1; $right -lt $People.Count; $right++) {
            $dx = [double] $People[$left].X - [double] $People[$right].X
            $dy = [double] $People[$left].Y - [double] $People[$right].Y
            $distance = [math]::Sqrt($dx * $dx + $dy * $dy)
            if ($distance -le $Radius) {
                [pscustomobject]@{ Pair = "$($People[$left].Name) + $($People[$right].Name)"; Distance = [math]::Round($distance, 2) }
            }
        }
    }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
Before the move:
Mira + Sol | distance=3.00
Sol + Tao | distance=3.00
After Nia walks closer:
Mira + Sol | distance=3.00
Sol + Tao | distance=3.00
Tao + Nia | distance=3.00
Checks passed: radius boundary, new link, no transitive shortcut, original snapshot preserved.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$frames = @(foreach ($step in @(0, 3, 6, 9)) { Get-LavaLampFrame -Step $step })
$again = @(foreach ($step in @(0, 3, 6, 9)) { Get-LavaLampFrame -Step $step })
if ($frames.Count -ne 60 -or ($frames -join "`n") -cne ($again -join "`n")) { throw 'Frame count or determinism failed.' }
$unique = [Collections.Generic.HashSet[string]]::new()
for ($frame = 0; $frame -lt 4; $frame++) {
    $start = $frame * 15
    $body = @($frames[($start + 2)..($start + 13)])
    if (@($body | Where-Object Length -NE 36).Count) { throw 'Frame dimensions failed.' }
    [void] $unique.Add(($body -join "`n"))
}
if ($unique.Count -ne 4) { throw 'Sampled frames did not change.' }
$frames
'Checks passed: four distinct sampled frames, fixed 34x12 field, deterministic replay.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Sample moving metaballs into a small terminal field; this is visual math, not fluid physics.
function Get-LavaLampFrame {
    [CmdletBinding()]
    param([ValidateRange(0, 40)][int] $Step = 0)
    $width = 34
    $height = 12
    $palette = ' .:-=+*#@'
    # Sine paths make the blobs move smoothly and repeatably without randomness or delays.
    $t = $Step * 0.42
    $balls = @(
        @{ X = 0.45 * [math]::Sin($t); Y = 0.55 * [math]::Cos($t * 0.7); Mass = 0.10 }
        @{ X = 0.52 * [math]::Cos($t * 0.9 + 1); Y = 0.45 * [math]::Sin($t); Mass = 0.08 }
        @{ X = 0.3 * [math]::Sin($t + 2); Y = -0.55 * [math]::Cos($t * 0.8); Mass = 0.06 }
    )
    'Frame {0:D2}' -f $Step
    '+' + ('-' * $width) + '+'
    for ($row = 0; $row -lt $height; $row++) {
        $line = [Text.StringBuilder]::new()
        for ($column = 0; $column -lt $width; $column++) {
            $x = 2 * $column / ($width - 1) - 1
            $y = 2 * $row / ($height - 1) - 1
            $field = 0.0
            foreach ($ball in $balls) {
                $dx = $x - $ball.X
                $dy = $y - $ball.Y
                # The floor prevents division by zero at a blob's center.
                $field += $ball.Mass / ($dx * $dx + $dy * $dy + 0.035)
            }
            $index = [int][math]::Floor([math]::Min($palette.Length - 1, $field * 2.2))
            [void] $line.Append($palette[$index])
        }
        '|' + $line.ToString() + '|'
    }
    '+' + ('-' * $width) + '+'
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
Frame 00
+----------------------------------+
|             ................     |
|           .........:::.........  |
|         ........::--=--::........|
|       .........::--===--::.......|
|      .........::::-----:::.......|
|     .........:::--=+++=--::......|
|    .........::::--=+++=-:::......|
|    ........:::--------::::.......|
|    .......::-=+**+=--:::.........|
|    .......::-=++*+=-:::......... |
|     ........:::::::::.........   |
|       ......................     |
+----------------------------------+
Frame 03
+----------------------------------+
|                                  |
|          ..............          |
|       .....................      |
|    ........:::--::::..........   |
|   ........::--===--::........... |
|  .........::::---:::::::.........|
| ........::::::::::::-----:::.....|
|.......:::--==-------=+**+=-::....|
|.......::-=+*+=------=++++=-::....|
| .......:::---::::::::::::::......|
|   ...............................|
|     ..........................   |
+----------------------------------+
Frame 06
+----------------------------------+
|                                  |
|           ...............        |
|     .........................    |
| .................::::::........  |
|............:::::---===-:::...... |
|.....::::::::::---=+*#*+--::......|
|...::--==+++===-----==--:::.......|
|..::--+*###**+=--:::::::......... |
|...:::--====---::::............   |
|......::::::::...............     |
|.........................         |
|   .................              |
+----------------------------------+
Frame 09
+----------------------------------+
|  .......................         |
|........:::::::::..........       |
|......::--==++==-:::........      |
|.....::--=*#@@#*+=-::........     |
|.....:::-==+##@#+=-:::.......     |
|.......:::--====--:::........     |
|.........::::::::::..........     |
|..........:::::::::.........      |
| .........::--=--::........       |
|   .......::-----::.......        |
|     ...................          |
|       ...............            |
+----------------------------------+
Checks passed: four distinct sampled frames, fixed 34x12 field, deterministic replay.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. "$PSScriptRoot/solution.ps1"

$tickets = @(
    [pscustomobject]@{ Id = 'T-101'; Message = 'The replacement arrived, but I was charged twice.' }
    [pscustomobject]@{ Id = 'T-102'; Message = 'I cannot sign in after changing my email.' }
    [pscustomobject]@{ Id = 'T-103'; Message = 'Can you tell me whether blue is available?' }
)

$fixture = @{
    'T-101' = @{ billing = 0.94; delivery = 0.86; account = 0.04 }
    'T-102' = @{ billing = 0.03; delivery = 0.06; account = 0.91 }
    'T-103' = @{ billing = 0.18; delivery = 0.58; account = 0.12 }
}

$tickets | Invoke-MultiTeamTicketRoute -Mode Fixture -Fixture $fixture |
    ForEach-Object {
        '{0}: routes=[{1}] review={2} billing={3:N2} delivery={4:N2} account={5:N2}' -f `
            $_.Id, ($_.Routes -join ', '), $_.NeedsReview, $_.Probabilities.billing,
            $_.Probabilities.delivery, $_.Probabilities.account
    }

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Route support tickets after a narrow semantic decision.
function Invoke-MultiTeamTicketRoute {
    [CmdletBinding()]
    param(
        # Tickets remain ordinary PowerShell objects throughout the workflow.
        [Parameter(Mandatory, ValueFromPipeline)]
        [psobject] $Ticket,

        # Fixture mode is safe and deterministic; Live uses the installed Jev module.
        [ValidateSet('Fixture', 'Live')]
        [string] $Mode = 'Fixture',

        # Fixture probabilities are keyed first by ticket ID, then by team name.
        [hashtable] $Fixture,

        # PowerShell owns this policy boundary, not the model.
        [ValidateRange(0.5, 1.0)]
        [double] $RouteThreshold = 0.75
    )

    begin {
        # These independent labels allow zero, one, or several teams to match.
        $tagDefinitions = [ordered]@{
            billing  = 'Charges, invoices, payments, or refunds.'
            delivery = 'Shipping, tracking, delivery dates, or damaged packages.'
            account  = 'Sign-in, profiles, identity, or account settings.'
        }

        # Load the current public command surface only when live calls are requested.
        if ($Mode -eq 'Live') {
            Import-Module Jev -MinimumVersion 0.4.0 -ErrorAction Stop
            if ([string]::IsNullOrWhiteSpace($env:TYPESAFE_API_KEY)) {
                throw 'Live mode requires TYPESAFE_API_KEY.'
            }
        }
    }

    process {
        if ([string]::IsNullOrWhiteSpace([string] $Ticket.Id) -or
            [string]::IsNullOrWhiteSpace([string] $Ticket.Message)) {
            throw 'Each ticket needs non-empty Id and Message values.'
        }

        if ($Mode -eq 'Fixture') {
            # Copy fixture values into a predictable ordered dictionary.
            if (-not $Fixture.ContainsKey([string] $Ticket.Id)) {
                throw "No fixture exists for ticket '$($Ticket.Id)'."
            }
            $probabilities = [ordered]@{}
            foreach ($team in $tagDefinitions.Keys) {
                $value = [double] $Fixture[[string] $Ticket.Id][$team]
                if ($value -lt 0 -or $value -gt 1) { throw "Invalid probability for $team." }
                $probabilities[$team] = $value
            }
        }
        else {
            # Add-JevTag performs one multi-label Jev decision for the ticket text.
            $decision = $Ticket.Message | Add-JevTag $tagDefinitions -Threshold $RouteThreshold
            $probabilities = [ordered]@{}
            foreach ($team in $tagDefinitions.Keys) {
                $probabilities[$team] = [double] $decision.$team
            }
        }

        # Deterministic PowerShell chooses the actual queues from the scores.
        $routes = @($tagDefinitions.Keys | Where-Object { $probabilities[$_] -ge $RouteThreshold })
        $highest = @($probabilities.Values | Measure-Object -Maximum).Maximum
        $needsReview = $routes.Count -eq 0 -and $highest -gt 0.40

        # Return an inspectable record rather than taking any external action.
        [pscustomobject]@{
            Id          = [string] $Ticket.Id
            Routes      = if ($needsReview) { @('human-review') } else { $routes }
            NeedsReview = $needsReview
            Probabilities = [pscustomobject] $probabilities
        }
    }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: ./pwsh -NoLogo -NoProfile -File ./run.ps1
Exit status: 0

STDOUT
T-101: routes=[billing, delivery] review=False billing=0.94 delivery=0.86 account=0.04
T-102: routes=[account] review=False billing=0.03 delivery=0.06 account=0.91
T-103: routes=[human-review] review=True billing=0.18 delivery=0.58 account=0.12

STDERR
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. "$PSScriptRoot/solution.ps1"

$ideas = @(
    [pscustomobject]@{ Idea = 'Pre-fill support replies'; RunsPerWeek = 70; MinutesSavedPerRun = 3; BuildHours = 8 }
    [pscustomobject]@{ Idea = 'Check release notes'; RunsPerWeek = 4; MinutesSavedPerRun = 25; BuildHours = 6 }
    [pscustomobject]@{ Idea = 'Rename photo batches'; RunsPerWeek = 2; MinutesSavedPerRun = 45; BuildHours = 5 }
    [pscustomobject]@{ Idea = 'Reconcile order totals'; RunsPerWeek = 12; MinutesSavedPerRun = 12; BuildHours = 14 }
    [pscustomobject]@{ Idea = 'Build meeting packets'; RunsPerWeek = 5; MinutesSavedPerRun = 35; BuildHours = 10 }
    [pscustomobject]@{ Idea = 'Archive old drafts'; RunsPerWeek = 1; MinutesSavedPerRun = 20; BuildHours = 7 }
    [pscustomobject]@{ Idea = 'Label incoming files'; RunsPerWeek = 40; MinutesSavedPerRun = 2; BuildHours = 4 }
)

$path = Join-Path $PSScriptRoot 'automation-payoff.xlsx'
$result = New-AutomationPayoffWorkbook -Idea $ideas -Path $path
"Workbook: $(Split-Path -Leaf $result.Path)"
"Ideas: $($result.Ideas)"
"Quick wins: $($result.QuickWins)"
"Top idea: $($result.TopIdea)"

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Build an Excel workbook that makes automation payoff easy to compare.
function New-AutomationPayoffWorkbook {
    [CmdletBinding()]
    param(
        # Each idea supplies a frequency, time saved per run, and build estimate.
        [Parameter(Mandatory)]
        [psobject[]] $Idea,

        # The caller controls where the generated workbook is written.
        [Parameter(Mandatory)]
        [string] $Path
    )

    # ImportExcel creates XLSX files without requiring Microsoft Excel.
    $savedWarningPreference = $WarningPreference
    $WarningPreference = 'SilentlyContinue'
    Import-Module ImportExcel -MinimumVersion 7.8.0 -ErrorAction Stop 4>$null
    $WarningPreference = $savedWarningPreference

    # Calculate comparable payoff metrics, then put the biggest wins first.
    $ranked = @($Idea | ForEach-Object {
        $weeklyHours = ([double] $_.RunsPerWeek * [double] $_.MinutesSavedPerRun) / 60
        $annualHours = $weeklyHours * 52
        [pscustomobject]@{
            Idea             = [string] $_.Idea
            RunsPerWeek      = [int] $_.RunsPerWeek
            MinutesSaved     = [double] $_.MinutesSavedPerRun
            BuildHours       = [double] $_.BuildHours
            AnnualHoursSaved = [math]::Round($annualHours, 1)
            PaybackWeeks     = if ($weeklyHours -gt 0) { [math]::Round($_.BuildHours / $weeklyHours, 1) } else { [double]::PositiveInfinity }
        }
    } | Sort-Object AnnualHoursSaved -Descending)

    # Add a cumulative share so readers can see the few ideas doing most of the work.
    $total = ($ranked | Measure-Object AnnualHoursSaved -Sum).Sum
    $running = 0.0
    $rows = @($ranked | ForEach-Object {
        $running += $_.AnnualHoursSaved
        [pscustomobject]@{
            Idea             = $_.Idea
            RunsPerWeek      = $_.RunsPerWeek
            MinutesSaved     = $_.MinutesSaved
            BuildHours       = $_.BuildHours
            AnnualHoursSaved = $_.AnnualHoursSaved
            PaybackWeeks     = $_.PaybackWeeks
            CumulativeShare  = if ($total -gt 0) { $running / $total } else { 0 }
        }
    })

    # Write the main sheet with a data bar that makes the largest savings stand out.
    $format = @{ Range = "E2:E$($rows.Count + 1)"; DataBarColor = 'Green' }
    $rows | Export-Excel -Path $Path -WorksheetName 'Payoff' -TableName 'PayoffTable' `
        -TableStyle Medium2 -BoldTopRow -FreezeTopRow -AutoFilter -ClearSheet `
        -ConditionalFormat $format

    # A short second sheet gives the reader an immediate shortlist.
    $quickWins = @($rows | Where-Object PaybackWeeks -LE 4 | Select-Object -First 5)
    $quickWins | Export-Excel -Path $Path -WorksheetName 'Quick Wins' -TableName 'QuickWinsTable' `
        -TableStyle Medium4 -BoldTopRow -FreezeTopRow -AutoFilter -ClearSheet

    # Return a small audit record after both sheets are saved.
    [pscustomobject]@{ Path = $Path; Ideas = $rows.Count; QuickWins = $quickWins.Count; TopIdea = $rows[0].Idea }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: ./pwsh -NoLogo -NoProfile -File ./run.ps1
Exit status: 0

STDOUT
Workbook: automation-payoff.xlsx
Ideas: 7
Quick wins: 5
Top idea: Pre-fill support replies

POWERSHELL WARNING STREAM
ImportExcel reported that automatic column fitting is unavailable because the optional libgdiplus dependency is not installed. The lab does not request AutoSize, and workbook creation and inspection completed successfully.

STDERR
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. "$PSScriptRoot/solution.ps1"

$records = @(
    [pscustomobject]@{ Id = 'A'; Stops = $null }
    [pscustomobject]@{ Id = 'B'; Stops = 'Oslo' }
    [pscustomobject]@{ Id = 'C'; Stops = @('Lima', 'Kyoto', 'Accra') }
)

$envelopes = @($records | ConvertTo-NestedListEnvelope -ListProperty Stops)
"Rows returned: $($envelopes.Count)"
foreach ($row in $envelopes) {
    '{0}: count={1}; items=[{2}]; type={3}' -f $row.Id, $row.Count, ($row.Items -join ', '), $row.Items.GetType().Name
}

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Convert each record into a stable envelope without unrolling its nested items.
function ConvertTo-NestedListEnvelope {
    [CmdletBinding()]
    param(
        # Records may arrive through the pipeline one at a time.
        [Parameter(Mandatory, ValueFromPipeline)]
        [psobject] $InputObject,

        # Name the property that contains the nested collection.
        [Parameter(Mandatory)]
        [string] $ListProperty,

        # Name the record identifier copied into the envelope.
        [string] $IdProperty = 'Id'
    )

    process {
        $idField = $InputObject.PSObject.Properties[$IdProperty]
        $listField = $InputObject.PSObject.Properties[$ListProperty]
        if ($null -eq $idField) { throw "Missing ID property '$IdProperty'." }
        if ($null -eq $listField) { throw "Missing list property '$ListProperty'." }

        # A generic list keeps the same runtime shape for zero, one, or many values.
        $items = [System.Collections.Generic.List[object]]::new()
        if ($null -ne $listField.Value) {
            foreach ($item in @($listField.Value)) { $items.Add($item) }
        }

        # The array lives inside one object property, so the pipeline emits one row.
        [pscustomobject]@{
            Id    = $idField.Value
            Count = $items.Count
            Items = $items
        }
    }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: ./pwsh -NoLogo -NoProfile -File ./run.ps1
Exit status: 0

STDOUT
Rows returned: 3
A: count=0; items=[]; type=List`1
B: count=1; items=[Oslo]; type=List`1
C: count=3; items=[Lima, Kyoto, Accra]; type=List`1

STDERR
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. "$PSScriptRoot/solution.ps1"

$links = @(
    @{ Name = 'Studio'; LatencyMs = @(24, 25, 23, 26, 24, 25); PacketLossPercent = 0.1 }
    @{ Name = 'Cafe'; LatencyMs = @(46, 91, 52, 110, 49, 84); PacketLossPercent = 1.8 }
    @{ Name = 'Train'; LatencyMs = @(130, 280, 95, 340, 170, 260); PacketLossPercent = 5.5 }
)

foreach ($link in $links) {
    $result = Measure-CallLinkReadiness @link
    '{0}: {1} | score={2:N1} latency={3:N1}ms jitter={4:N1}ms loss={5:N1}%' -f `
        $result.Name, $result.Verdict, $result.QualityScore, $result.AverageLatencyMs,
        $result.AverageJitterMs, $result.PacketLossPercent
}

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Turn bounded latency and loss samples into a simple readiness estimate.
function Measure-CallLinkReadiness {
    [CmdletBinding()]
    param(
        # A friendly name makes side-by-side results easy to read.
        [Parameter(Mandatory)]
        [string] $Name,

        # Latency samples are supplied by the caller; this function makes no probes.
        [Parameter(Mandatory)]
        [ValidateCount(2, 1000)]
        [double[]] $LatencyMs,

        # Loss is a percentage from zero through one hundred.
        [ValidateRange(0, 100)]
        [double] $PacketLossPercent
    )

    if ($LatencyMs | Where-Object { $_ -lt 0 -or [double]::IsNaN($_) -or [double]::IsInfinity($_) }) {
        throw 'Latency samples must be finite, non-negative numbers.'
    }

    # Average latency describes delay, while adjacent differences expose instability.
    $average = ($LatencyMs | Measure-Object -Average).Average
    $deltas = for ($index = 1; $index -lt $LatencyMs.Count; $index++) {
        [math]::Abs($LatencyMs[$index] - $LatencyMs[$index - 1])
    }
    $jitter = ($deltas | Measure-Object -Average).Average

    # This transparent teaching score is a heuristic, not a telecom standard.
    $score = 100 - ($average * 0.18) - ($jitter * 1.6) - ($PacketLossPercent * 12)
    $score = [math]::Round([math]::Max(0, [math]::Min(100, $score)), 1)
    $verdict = if ($score -ge 80) { 'Smooth' } elseif ($score -ge 55) { 'Shaky' } else { 'Painful' }

    [pscustomobject]@{
        Name              = $Name
        AverageLatencyMs  = [math]::Round($average, 1)
        AverageJitterMs   = [math]::Round($jitter, 1)
        PacketLossPercent = [math]::Round($PacketLossPercent, 1)
        QualityScore      = $score
        Verdict           = $verdict
    }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: ./pwsh -NoLogo -NoProfile -File ./run.ps1
Exit status: 0

STDOUT
Studio: Smooth | score=92.0 latency=24.5ms jitter=1.8ms loss=0.1%
Cafe: Painful | score=0.0 latency=72.0ms jitter=47.6ms loss=1.8%
Train: Painful | score=0.0 latency=212.5ms jitter=168.0ms loss=5.5%

STDERR
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. "$PSScriptRoot/solution.ps1"
Get-SynchronizedFireflyFrames -FrameCount 12

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Simulate a small ring of coupled fireflies and return printable frames.
function Get-SynchronizedFireflyFrames {
    [CmdletBinding()]
    param(
        # A small bounded frame count keeps automated runs quick.
        [ValidateRange(1, 40)]
        [int] $FrameCount = 12
    )

    # Fixed phases make every validation run reproducible.
    [int[]] $phases = @(0, 6, 3, 1, 7, 4, 2, 5)
    $cycle = 8

    for ($frame = 0; $frame -lt $FrameCount; $frame++) {
        # Phase zero is the instant a firefly flashes.
        $lights = foreach ($phase in $phases) {
            if ($phase -eq 0) { '✦' } elseif ($phase -in 1, 7) { '·' } else { ' ' }
        }
        'Frame {0:D2}  meadow | {1} |' -f ($frame + 1), ($lights -join '  ')

        # Each firefly advances once, plus a gentle nudge when a neighbor flashes.
        $next = [int[]]::new($phases.Count)
        for ($index = 0; $index -lt $phases.Count; $index++) {
            $left = ($index - 1 + $phases.Count) % $phases.Count
            $right = ($index + 1) % $phases.Count
            $neighborFlash = $phases[$left] -eq 0 -or $phases[$right] -eq 0
            $step = if ($neighborFlash -and $phases[$index] -ge 4) { 2 } else { 1 }
            $next[$index] = ($phases[$index] + $step) % $cycle
        }
        $phases = $next
    }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: ./pwsh -NoLogo -NoProfile -File ./run.ps1
Exit status: 0

STDOUT
Frame 01  meadow | ✦        ·  ·          |
Frame 02  meadow | ·  ✦        ✦        · |
Frame 03  meadow |    ·        ·  ·     ✦ |
Frame 04  meadow |       ·        ✦     · |
Frame 05  meadow |       ✦        ·  ✦    |
Frame 06  meadow |       ·  ·        ·    |
Frame 07  meadow |          ✦             |
Frame 08  meadow | ·        ·  ·          |
Frame 09  meadow | ✦  ·        ✦          |
Frame 10  meadow | ·  ·        ·  ·     ✦ |
Frame 11  meadow |                ✦  ·  · |
Frame 12  meadow |       ·        ·  ·    |

STDERR
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference='Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$cards=@(
    [pscustomobject]@{Title='A postcard from raw CSV';Description='Build an HTML card from three CSV rows.';FixtureProbability=.91}
    [pscustomobject]@{Title='Small tables, clear headings';Description='Format a small CSV table as readable HTML.';FixtureProbability=.91}
    [pscustomobject]@{Title='A dashboard with a server';Description='Host a dashboard with a backend and a database.';FixtureProbability=.55}
    [pscustomobject]@{Title='The history of markup';Description='A talk about how markup languages evolved.';FixtureProbability=.12}
)
$goal='Turn a tiny CSV into a standalone HTML page without a server.'
$result=@(Get-TutorialShortlist -Cards $cards -Goal $goal -Mode Fixture)
$result | Format-Table -AutoSize
if (($result.Action -join ',') -ne 'Recommend,Recommend,Human review,Set aside') { throw 'Review policy failed.' }
if ($result[0].Title -ne $cards[0].Title -or $result[1].Title -ne $cards[1].Title) { throw 'Tie order changed.' }
# Exercise the actual current Jev mock path separately from the authored fixture data.
$mock=@(Get-TutorialShortlist -Cards $cards -Goal $goal -Mode Mock)
if ($mock.Count -ne 4 -or @($mock | Where-Object DecisionSource -ne Mock).Count) { throw 'Mock contract failed.' }
$bad=[pscustomobject]@{Title='Bad fixture';Description='Not a tutorial';FixtureProbability=1.2}
$rejected=$false
try { Get-TutorialShortlist -Cards @($bad) -Goal $goal | Out-Null } catch { $rejected=$true }
if (-not $rejected) { throw 'Invalid probability accepted.' }
'Checks passed: fixture policy, stable ties, 4 current Jev mock answers, invalid probability rejection.'
'Live API: not called. Fixture probabilities are authored sample data, not AI predictions.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Keep the semantic judgment separate from deterministic ranking and review policy.
function Get-TutorialShortlist {
    param(
        [Parameter(Mandatory)][object[]] $Cards,
        [Parameter(Mandatory)][string] $Goal,
        [ValidateSet('Fixture','Mock','Live')][string] $Mode='Fixture'
    )
    # Current Jev supplies the typed question and optional model integration.
    Import-Module Jev -ErrorAction Stop
    $q = New-JevQuestion -Name relevant -Type Noul -Instructions "Does this tutorial directly teach this goal: $Goal?"
    $judged = @(foreach ($card in $Cards) {
        if ($Mode -eq 'Fixture') {
            # These authored values test policy, not model quality or calibration.
            $response = [pscustomobject]@{ answers=@{relevant=[pscustomobject]@{type='noul';noul=$card.FixtureProbability}} }
        } else {
            # Mock uses Jev's local keyword rules; Live is an explicit opt-in only.
            $argsForJev = @{State=$card.Description;Question=$q;Raw=$true;ErrorAction='Stop'}
            if ($Mode -eq 'Mock') { $argsForJev.Mock=$true }
            $response = Invoke-Jev @argsForJev
        }
        # Missing, nonnumeric, or out-of-range answers must not become recommendations.
        $answer = $response.answers.relevant
        if ($null -eq $answer -or $answer.type -ne 'noul' -or $null -eq $answer.noul) { throw 'Missing Noul relevance answer.' }
        $p = 0.0
        if (-not [double]::TryParse([string]$answer.noul,[Globalization.NumberStyles]::Float,[Globalization.CultureInfo]::InvariantCulture,[ref]$p) -or [double]::IsNaN($p) -or $p -lt 0 -or $p -gt 1) { throw 'Invalid relevance probability.' }
        # The policy belongs to PowerShell and stays visible regardless of decision source.
        $action = if ($p -ge .8) {'Recommend'} elseif ($p -ge .4) {'Human review'} else {'Set aside'}
        [pscustomobject]@{Title=$card.Title;Probability=$p;Action=$action;DecisionSource=$Mode}
    })
    # Stable sorting preserves input order for exact ties; no returned text is executed.
    $judged | Sort-Object Probability -Descending -Stable
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:

Title                        Probability Action       DecisionSource
-----                        ----------- ------       --------------
A postcard from raw CSV             0.91 Recommend    Fixture
Small tables, clear headings        0.91 Recommend    Fixture
A dashboard with a server           0.55 Human review Fixture
The history of markup               0.12 Set aside    Fixture

Checks passed: fixture policy, stable ties, 4 current Jev mock answers, invalid probability rejection.
Live API: not called. Fixture probabilities are authored sample data, not AI predictions.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$files = [ordered]@{
    'hello.txt' = 'Hello, future maker!'
    'recipe.txt' = "One cup of curiosity.`nTwo spoonfuls of patience."
    'badge.txt' = 'Pocket project: café lantern ☀'
}
$capsule = New-TextCapsule -Files $files
$capsule.Entries | Format-Table -AutoSize
"Archive bytes: $($capsule.ArchiveBytes)"
if ($capsule.Entries.Count -ne 3 -or $capsule.Entries.HashMatches -contains $false) { throw 'Content proof failed.' }
# Demonstrate that a traversal-style name is rejected before it can become an entry.
$rejected = $false
try { New-TextCapsule -Files @{'../escape.txt'='no'} | Out-Null } catch { $rejected = $true }
if (-not $rejected) { throw 'Unsafe name was accepted.' }
'Checks passed: 3 UTF-8 round trips; unsafe entry name rejected.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Build and inspect a tiny ZIP entirely in memory.
function New-TextCapsule {
    param([Parameter(Mandatory)][System.Collections.IDictionary] $Files)
    # Keep the sample bounded and require at least one entry.
    if ($Files.Count -lt 1 -or $Files.Count -gt 20) { throw 'Supply 1 to 20 text entries.' }
    $expected = @{}
    $buffer = [System.IO.MemoryStream]::new()
    try {
        # Leave the backing stream open so it can be inspected after ZIP finalization.
        $zip = [System.IO.Compression.ZipArchive]::new($buffer, 'Create', $true)
        try {
            foreach ($name in $Files.Keys) {
                # Flat names eliminate traversal paths; no extraction is performed anyway.
                if ([string]$name -notmatch '^[A-Za-z0-9_-]+\.[A-Za-z0-9]+#39;) { throw 'Use simple flat entry names.' }
                $bytes = [System.Text.Encoding]::UTF8.GetBytes([string]$Files[$name])
                if ($bytes.Length -gt 65536) { throw 'Each entry must be at most 64 KiB.' }
                # Record a content fingerprint before compression, not archive metadata.
                $expected[$name] = [Convert]::ToHexString([System.Security.Cryptography.SHA256]::HashData($bytes))
                $entry = $zip.CreateEntry($name, 'Optimal')
                $stream = $entry.Open()
                try { $stream.Write($bytes, 0, $bytes.Length) } finally { $stream.Dispose() }
            }
        } finally { $zip.Dispose() }
        # Reopen the finalized archive; timestamps do not affect the content proof.
        $archiveBytes = $buffer.Length
        $buffer.Position = 0
        $reader = [System.IO.Compression.ZipArchive]::new($buffer, 'Read', $true)
        try {
            $entries = @(foreach ($entry in $reader.Entries) {
                $stream = $entry.Open()
                $copy = [System.IO.MemoryStream]::new()
                try {
                    $stream.CopyTo($copy)
                    $actual = [Convert]::ToHexString([System.Security.Cryptography.SHA256]::HashData($copy.ToArray()))
                    [pscustomobject]@{ Name=$entry.FullName; Bytes=$copy.Length; HashMatches=($actual -ceq $expected[$entry.FullName]) }
                } finally { $stream.Dispose(); $copy.Dispose() }
            })
            [pscustomobject]@{ ArchiveBytes=$archiveBytes; Entries=$entries }
        } finally { $reader.Dispose() }
    } finally { $buffer.Dispose() }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:

Name       Bytes HashMatches
----       ----- -----------
hello.txt     20        True
recipe.txt    48        True
badge.txt     33        True

Archive bytes: 411
Checks passed: 3 UTF-8 round trips; unsafe entry name rejected.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference='Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$result=Invoke-Sandpile -Size 9 -Grains 180
'. = 0, o = 1, O = 2, # = 3, * = crowded'
$result.Frames -join "`n`n"
"Topplings: $($result.Topplings); remaining: $($result.Remaining); escaped: $($result.Escaped)"
if (-not $result.MassMatches) { throw 'Grains were lost from the ledger.' }
foreach ($n in $result.Grid) { if ($n -lt 0 -or $n -gt 3) { throw 'Grid is not stable.' } }
# Repeat to check deterministic output and exercise boundary loss separately.
$again=Invoke-Sandpile -Size 9 -Grains 180
if (($again.Frames -join '|') -cne ($result.Frames -join '|')) { throw 'Frames changed between runs.' }
$edge=Invoke-Sandpile -Size 5 -Grains 400
if ($edge.Escaped -le 0 -or -not $edge.MassMatches) { throw 'Open boundary ledger failed.' }
'Checks passed: stable grid, conserved ledger, repeatable frames, open-boundary loss.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Model a sandpile with open boundaries and an explicit conservation ledger.
function Invoke-Sandpile {
    param([ValidateRange(5,21)][int]$Size=9,[ValidateRange(1,2000)][int]$Grains=180)
    if ($Size % 2 -eq 0) { throw 'Use an odd grid size.' }
    $grid=[int[,]]::new($Size,$Size)
    $center=[int][math]::Floor($Size/2)
    $grid[$center,$center]=$Grains
    $escaped=0; $topplings=0; $rounds=0
    $frames=[System.Collections.Generic.List[string]]::new()
    do {
        $changed=$false
        $next=[int[,]]$grid.Clone()
        # Parallel rounds topple each crowded cell once; each update uses old state.
        for ($y=0; $y -lt $Size; $y++) {
            for ($x=0; $x -lt $Size; $x++) {
                if ($grid[$y,$x] -lt 4) { continue }
                $changed=$true; $topplings++; $next[$y,$x]-=4
                foreach ($step in @(@(-1,0),@(1,0),@(0,-1),@(0,1))) {
                    $ny=$y+$step[0]; $nx=$x+$step[1]
                    if ($ny -lt 0 -or $ny -ge $Size -or $nx -lt 0 -or $nx -ge $Size) { $escaped++ }
                    else { $next[$ny,$nx]++ }
                }
            }
        }
        $grid=$next; $rounds++
        if ($rounds -gt 20000) { throw 'Simulation reached its safety bound.' }
        # Capture a few informative frames without sleeping or clearing the terminal.
        if ($rounds -in @(1,20,60) -or -not $changed) {
            $lines=@(for ($y=0; $y -lt $Size; $y++) {
                -join @(for ($x=0; $x -lt $Size; $x++) {
                    if ($grid[$y,$x] -ge 4) {'*'} else { '.oO#'[$grid[$y,$x]] }
                })
            })
            $frames.Add("Round $rounds`n"+($lines -join "`n"))
        }
    } while ($changed)
    # Account for every grain, including losses at the open boundary.
    $remaining=0
    foreach ($n in $grid) { $remaining+=$n }
    [pscustomobject]@{Grid=$grid;Frames=$frames.ToArray();Rounds=$rounds;Topplings=$topplings;Escaped=$escaped;Remaining=$remaining;MassMatches=($remaining+$escaped -eq $Grains)}
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
. = 0, o = 1, O = 2, # = 3, * = crowded
Round 1
.........
.........
.........
....o....
...o*o...
....o....
.........
.........
.........

Round 20
.........
....o....
...#O#...
..#*o*#..
.oOo*oOo.
..#*o*#..
...#O#...
....o....
.........

Round 60
..oO#Oo..
.OO#O#OO.
oO.#o#.Oo
O##O*O##O
#Oo***oO#
O##O*O##O
oO.#o#.Oo
.OO#O#OO.
..oO#Oo..

Round 90
.#Oo#oO#.
#.oO#Oo.#
OoO#o#OoO
oO#OOO#Oo
##oO.Oo##
oO#OOO#Oo
OoO#o#OoO
#.oO#Oo.#
.#Oo#oO#.
Topplings: 673; remaining: 148; escaped: 32
Checks passed: stable grid, conserved ledger, repeatable frames, open-boundary loss.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$tools = @(
    [pscustomobject]@{ID='001';Tool='Mini loom';Cost=90;Sessions=30}
    [pscustomobject]@{ID='002';Tool='Clay wheel';Cost=600;Sessions=40}
    [pscustomobject]@{ID='003';Tool='Vinyl cutter';Cost=250;Sessions=5}
    [pscustomobject]@{ID='004';Tool='Button press';Cost=120;Sessions=0}
)
# Create a unique local file beside the lab; repeated runs never replace a workbook.
$path = Join-Path $PSScriptRoot ('gadget-use-'+[guid]::NewGuid().ToString('N')+'.xlsx')
New-GadgetWorkbook -Tools $tools -Path $path | Out-Null
$package = Open-ExcelPackage -Path $path
try {
    $s = $package.Workbook.Worksheets['Shelf']
    if ($s.Dimension.Rows -ne 5 -or $s.ConditionalFormatting.Count -ne 1) { throw 'Workbook structure failed.' }
    $expected = @(3,15,50,0)
    for ($i=0; $i -lt 4; $i++) {
        $r=$i+2
        if ($s.Cells[$r,1].Value -cne $tools[$i].ID -or [double]$s.Cells[$r,5].Value -ne $expected[$i]) { throw 'Cell value failed.' }
        if ($s.Cells[$r,5].Formula -ne "IF(D$r=0,0,C$r/D$r)") { throw 'Formula was lost.' }
        '{0}: {1}, {2} sessions, cost/session {3:0.00}' -f $tools[$i].ID,$tools[$i].Tool,$tools[$i].Sessions,$s.Cells[$r,5].Value
    }
    if ($s.Cells[5,6].Value -ne 'Unused') { throw 'Unused guard failed.' }
    'Checks passed: zero-padded IDs, 4 formulas, cached values, unused guard, data bar rule.'
    'Workbook created beside run.ps1: gadget-use-<unique-id>.xlsx'
} finally { $package.Dispose() }

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Create a local workbook with inspectable formulas and usage data bars.
function New-GadgetWorkbook {
    param([Parameter(Mandatory)][object[]] $Tools, [Parameter(Mandatory)][string] $Path)
    # Refuse to overwrite an existing file; each run chooses a fresh name.
    if (Test-Path -LiteralPath $Path) { throw 'Choose a new workbook path.' }
    Import-Module ImportExcel -ErrorAction Stop
    foreach ($tool in $Tools) {
        # Guard the denominator and costs before exporting fictional records.
        if ($tool.Cost -lt 0 -or $tool.Sessions -lt 0) { throw 'Cost and sessions cannot be negative.' }
    }
    $rows = @(foreach ($tool in $Tools) {
        [pscustomobject][ordered]@{
            ID=[string]$tool.ID; Tool=$tool.Tool; Cost=[double]$tool.Cost
            Sessions=[int]$tool.Sessions; CostPerSession=''; Status=''
        }
    })
    # Fixed widths avoid platform-specific font measurement dependencies.
    $package = $rows | Export-Excel -Path $Path -WorksheetName 'Shelf' -NoNumberConversion ID -FreezeTopRow -AutoFilter -BoldTopRow -PassThru
    try {
        $sheet = $package.Workbook.Worksheets['Shelf']
        for ($r=2; $r -le $rows.Count+1; $r++) {
            # Guard zero use explicitly and keep the numeric formula recalculable.
            $sheet.Cells[$r,5].Formula = "IF(D$r=0,0,C$r/D$r)"
            $sheet.Cells[$r,6].Formula = "IF(D$r=0,`"Unused`",`"In play`")"
        }
        $sheet.Cells["C2:E$($rows.Count+1)"].Style.Numberformat.Format = '0.00'
        $sheet.Cells["D2:D$($rows.Count+1)"].Style.Numberformat.Format = '0'
        $sheet.Column(1).Width=10; $sheet.Column(2).Width=24
        foreach ($c in 3..6) { $sheet.Column($c).Width=19 }
        # Data bars show frequency independently of purchase cost.
        Add-ConditionalFormatting -Worksheet $sheet -Address "D2:D$($rows.Count+1)" -DataBarColor Blue | Out-Null
        [OfficeOpenXml.CalculationExtension]::Calculate($package.Workbook)
        $package.Save()
    } finally { $package.Dispose() }
    # Return only the path, letting the runner independently reopen it.
    $Path
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:
WARNING: ImportExcel Module Cannot Autosize. Please run the following command to install dependencies:
apt-get -y update && apt-get install -y --no-install-recommends libgdiplus libc6-dev
001: Mini loom, 30 sessions, cost/session 3.00
002: Clay wheel, 40 sessions, cost/session 15.00
003: Vinyl cutter, 5 sessions, cost/session 50.00
004: Button press, 0 sessions, cost/session 0.00
Checks passed: zero-padded IDs, 4 formulas, cached values, unused guard, data bar rule.
Workbook created beside run.ps1: gadget-use-<unique-id>.xlsx

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

$ErrorActionPreference='Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$text=@'
Name,Name,Name_2,,"Note, long"
Ada,Bo,001,green,"Two lines:
still the same cell"
Cai,Dee,002,blue,"Hello, maker"
'@
$result=ConvertFrom-CsvWithUniqueHeaders -Text $text
$result.HeaderMap | Format-Table -AutoSize
$result.Rows | ConvertTo-Json -Depth 4
if (($result.HeaderMap.Assigned -join '|') -ne 'Name|Name_3|Name_2|Column4|Note, long') { throw 'Collision handling failed.' }
if ($result.Rows.Count -ne 2 -or $result.Rows[0].Name_2 -cne '001' -or $result.Rows[1].'Note, long' -cne 'Hello, maker') { throw 'Cell preservation failed.' }
if ($result.Rows[0].'Note, long' -notmatch 'Two lines:\r?\nstill the same cell') { throw 'Multiline cell failed.' }
# Verify case-insensitive collisions and an existing synthesized-looking header.
$edge=ConvertFrom-CsvWithUniqueHeaders -Text "Name,name,,Column3`na,b,c,d"
if (($edge.HeaderMap.Assigned -join '|') -ne 'Name|name_2|Column3_2|Column3') { throw 'Edge collision failed.' }
$rejected=$false
try { ConvertFrom-CsvWithUniqueHeaders -Text "A,B`nonlyone" | Out-Null } catch { $rejected=$true }
if (-not $rejected) { throw 'Wrong-width row accepted.' }
'Checks passed: suffix collisions, blank and case variants, quoted commas, multiline text, leading zeros, width rejection.'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Parse CSV records before repairing names, so quoted commas and newlines stay intact.
function ConvertFrom-CsvWithUniqueHeaders {
    param([Parameter(Mandatory)][string] $Text)
    $reader=[System.IO.StringReader]::new($Text)
    $parser=[Microsoft.VisualBasic.FileIO.TextFieldParser]::new($reader)
    try {
        $parser.SetDelimiters(',')
        $parser.HasFieldsEnclosedInQuotes=$true
        $parser.TrimWhiteSpace=$false
        if ($parser.EndOfData) { throw 'CSV needs a header record.' }
        $original=$parser.ReadFields()
        # Reserve all nonblank original names so generated suffixes cannot steal them.
        $reserved=[System.Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
        foreach ($name in $original) { if (-not [string]::IsNullOrWhiteSpace($name)) { [void]$reserved.Add($name) } }
        $used=[System.Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
        $mapping=@(for ($i=0; $i -lt $original.Count; $i++) {
            $base=if ([string]::IsNullOrWhiteSpace($original[$i])) { 'Column'+($i+1) } else { $original[$i] }
            $candidate=$base
            $suffix=2
            # Keep a first real header as-is; synthesized names avoid every reserved name.
            while ($used.Contains($candidate) -or ([string]::IsNullOrWhiteSpace($original[$i]) -and $reserved.Contains($candidate)) -or ($candidate -ne $base -and $reserved.Contains($candidate))) {
                $candidate=$base+'_'+$suffix
                $suffix++
            }
            [void]$used.Add($candidate)
            [pscustomobject]@{Position=$i+1;Original=$original[$i];Assigned=$candidate}
        })
        $rows=[System.Collections.Generic.List[object]]::new()
        while (-not $parser.EndOfData) {
            $cells=$parser.ReadFields()
            # Never silently shift or discard fields when a record has the wrong width.
            if ($cells.Count -ne $original.Count) { throw 'CSV row width differs from the header.' }
            $record=[ordered]@{}
            for ($i=0; $i -lt $cells.Count; $i++) { $record[$mapping[$i].Assigned]=$cells[$i] }
            $rows.Add([pscustomobject]$record)
        }
        [pscustomobject]@{HeaderMap=$mapping;Rows=$rows.ToArray()}
    } finally { $parser.Dispose(); $reader.Dispose() }
}

Captured output, errors, and exit status.

PowerShell version: 7.6.6
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: 0

Standard output:

Position Original   Assigned
-------- --------   --------
       1 Name       Name
       2 Name       Name_3
       3 Name_2     Name_2
       4            Column4
       5 Note, long Note, long

[
  {
    "Name": "Ada",
    "Name_3": "Bo",
    "Name_2": "001",
    "Column4": "green",
    "Note, long": "Two lines:\nstill the same cell"
  },
  {
    "Name": "Cai",
    "Name_3": "Dee",
    "Name_2": "002",
    "Column4": "blue",
    "Note, long": "Hello, maker"
  }
]
Checks passed: suffix collisions, blank and case variants, quoted commas, multiline text, leading zeros, width rejection.

Standard error:
(none)

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Stop on errors so a failed check cannot be mistaken for a successful calculation.
$ErrorActionPreference = 'Stop'
# Resolve the solution beside this runner.
$solution = Join-Path $PSScriptRoot 'solution.ps1'
# Evaluate examples that cover precedence, parentheses, unary signs, and exponentiation.
$results = @(& $solution -Expression @('2 + 3 * (4 - 1)', '-2^2 + 10', '2^3^2'))
# Print the useful values as a compact table.
$results | Format-Table -AutoSize
# Confirm that division by zero is rejected by the parser.
$rejected = $false
try { & $solution -Expression @('4 / 0') | Out-Null } catch { $rejected = $_.Exception.Message -like '*Division by zero*' }
# Fail the runner if the calculator accepts division by zero.
if (-not $rejected) { throw 'The divide-by-zero check failed.' }
# Confirm command-like input is rejected instead of executed.
$rejectedCode = $false
try { & $solution -Expression @('Get-Date') | Out-Null } catch { $rejectedCode = $_.Exception.Message -like '*Unsupported input*' }
# Fail if non-math text is accepted.
if (-not $rejectedCode) { throw 'The code-rejection check failed.' }
# Emit explicit checks for the captured validation record.
'Checks: precedence, parentheses, unary signs, right-associative powers, divide-by-zero rejection, command-text rejection'
'Status: passed'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Accept a small arithmetic language instead of executing user text as PowerShell.
param(
    # Evaluate one or more arithmetic expressions supplied by the caller.
    [Parameter(Mandatory)]
    [string[]] $Expression
)
# Stop on any parser or math error so a caller cannot mistake rejection for a result.
$ErrorActionPreference = 'Stop'

# Turn only numbers and the approved arithmetic punctuation into tokens.
function ConvertTo-MathToken {
    param([Parameter(Mandatory)][string] $Text)
    # Keep tokens in order so the parser preserves the original operator sequence.
    $tokens = [System.Collections.Generic.List[object]]::new()
    # Track the part of the input that has not been examined.
    $remaining = $Text
    # Consume the whole string; an unknown character is an error, not executable code.
    while ($remaining.Length -gt 0) {
        # Ignore spaces between tokens without changing token content.
        $remaining = $remaining.TrimStart()
        # Finish when only spaces remain.
        if ($remaining.Length -eq 0) { break }
        # Read a decimal number with an invariant decimal point.
        $number = [regex]::Match($remaining, '^(?:\d+(?:\.\d*)?|\.\d+)')
        if ($number.Success) {
            # Store token kind and value separately for predictable parsing.
            $tokens.Add([pscustomobject]@{ Kind = 'Number'; Value = $number.Value })
            # Continue immediately after the number.
            $remaining = $remaining.Substring($number.Length)
            continue
        }
        # Permit only arithmetic operators and grouping parentheses.
        $operator = [regex]::Match($remaining, '^[()+*/^\-]')
        if ($operator.Success) {
            # Store each operator as a one-character token.
            $tokens.Add([pscustomobject]@{ Kind = 'Operator'; Value = $operator.Value })
            # Continue immediately after the operator.
            $remaining = $remaining.Substring(1)
            continue
        }
        # Reject variables, commands, member access, and every other character.
        throw "Unsupported input near '$($remaining.Substring(0, [Math]::Min(12, $remaining.Length)))'. Only numbers, spaces, parentheses, and + - * / ^ are allowed."
    }
    # Return a stable token array for the recursive-descent parser.
    return ,$tokens.ToArray()
}

# Read an expression made from terms joined by addition or subtraction.
function Read-MathExpression {
    param([hashtable] $Context)
    # Begin with the first multiplicative term.
    $value = Read-MathTerm -Context $Context
    # Apply addition and subtraction from left to right.
    while ($Context.Index -lt $Context.Tokens.Count) {
        # Read the next operator without advancing the token index.
        $token = $Context.Tokens[$Context.Index]
        # Stop when this grammar level has no more plus or minus operators.
        if ($token.Kind -ne 'Operator' -or $token.Value -notin @('+', '-')) { break }
        # Consume the operator before reading its right-hand term.
        $Context.Index = [int] $Context.Index + 1
        # Parse multiplication and division before combining this term.
        $right = Read-MathTerm -Context $Context
        # Apply the selected operation to the accumulated value.
        if ($token.Value -eq '+') { $value += $right } else { $value -= $right }
    }
    # Return the completed additive expression.
    return $value
}

# Read multiplication and division, which bind more tightly than addition.
function Read-MathTerm {
    param([hashtable] $Context)
    # Begin with the first signed power expression.
    $value = Read-MathUnary -Context $Context
    # Apply multiplication and division from left to right.
    while ($Context.Index -lt $Context.Tokens.Count) {
        # Inspect the next operator at this grammar level.
        $token = $Context.Tokens[$Context.Index]
        # Stop when the next token is not multiplication or division.
        if ($token.Kind -ne 'Operator' -or $token.Value -notin @('*', '/')) { break }
        # Consume the operator before reading the right-hand value.
        $Context.Index = [int] $Context.Index + 1
        # Parse signs and exponents before applying this operation.
        $right = Read-MathUnary -Context $Context
        # Refuse division by zero instead of returning a misleading value.
        if ($token.Value -eq '/' -and $right -eq 0) { throw 'Division by zero is not allowed.' }
        # Apply multiplication or division to the accumulated value.
        if ($token.Value -eq '*') { $value *= $right } else { $value /= $right }
    }
    # Return the completed multiplicative term.
    return $value
}

# Read optional unary signs while preserving exponent precedence.
function Read-MathUnary {
    param([hashtable] $Context)
    # Inspect the next token for a leading sign.
    if ($Context.Index -lt $Context.Tokens.Count) {
        # Capture the token before advancing.
        $token = $Context.Tokens[$Context.Index]
        # Recursively accept a chain of leading plus or minus signs.
        if ($token.Kind -eq 'Operator' -and $token.Value -in @('+', '-')) {
            # Consume the unary sign.
            $Context.Index = [int] $Context.Index + 1
            # Parse the signed value that follows.
            $value = Read-MathUnary -Context $Context
            # Negate only for a minus sign.
            if ($token.Value -eq '-') { return -$value }
            # A plus sign leaves the numeric value unchanged.
            return $value
        }
    }
    # Parse an exponent after unary signs have been considered.
    return Read-MathPower -Context $Context
}

# Read exponentiation from right to left, as in 2^3^2 = 2^(3^2).
function Read-MathPower {
    param([hashtable] $Context)
    # Begin with a number or parenthesized expression.
    $left = Read-MathPrimary -Context $Context
    # Exponentiation is optional at this grammar level.
    if ($Context.Index -lt $Context.Tokens.Count) {
        # Inspect the next token without consuming it.
        $token = $Context.Tokens[$Context.Index]
        if ($token.Kind -eq 'Operator' -and $token.Value -eq '^') {
            # Consume the exponent operator.
            $Context.Index = [int] $Context.Index + 1
            # Parse the right side recursively to keep exponentiation right-associative.
            $right = Read-MathUnary -Context $Context
            # Bound exponent size so accidental large calculations stay small and quick.
            if ([Math]::Abs($right) -gt 12) { throw 'Exponent magnitude must be 12 or less.' }
            # Calculate with a numeric operation, never an expression evaluator.
            $left = [Math]::Pow($left, $right)
        }
    }
    # Return the numeric power expression.
    return $left
}

# Read a number or a complete expression inside parentheses.
function Read-MathPrimary {
    param([hashtable] $Context)
    # Reject a missing number or closing parenthesis.
    if ($Context.Index -ge $Context.Tokens.Count) { throw 'An expression ended where a number was expected.' }
    # Capture and consume the next token.
    $token = $Context.Tokens[$Context.Index]
    $Context.Index = [int] $Context.Index + 1
    # Parse a numeric token using a culture-independent decimal point.
    if ($token.Kind -eq 'Number') { return [double]::Parse($token.Value, [Globalization.CultureInfo]::InvariantCulture) }
    # Parse a nested expression after an opening parenthesis.
    if ($token.Value -eq '(') {
        # Evaluate only through this parser's approved grammar.
        $value = Read-MathExpression -Context $Context
        # Require a matching closing parenthesis.
        if ($Context.Index -ge $Context.Tokens.Count -or $Context.Tokens[$Context.Index].Value -ne ')') { throw 'A closing parenthesis is missing.' }
        # Consume the closing parenthesis.
        $Context.Index = [int] $Context.Index + 1
        # Return the value inside the parentheses.
        return $value
    }
    # Reject any operator where a primary number was required.
    throw "Unexpected token '$($token.Value)'; a number or '(' was expected."
}

# Parse every supplied expression and emit one structured result per input.
foreach ($item in $Expression) {
    # Tokenize first so unsupported characters are rejected before calculation.
    $tokens = ConvertTo-MathToken -Text $item
    # Refuse empty input rather than returning an accidental zero.
    if ($tokens.Count -eq 0) { throw 'The expression cannot be empty.' }
    # Share parser position through one mutable context object.
    $context = @{ Tokens = $tokens; Index = 0 }
    # Parse the complete arithmetic expression.
    $value = Read-MathExpression -Context $context
    # Reject any extra token left after a valid expression.
    if ($context.Index -ne $tokens.Count) { throw "Unexpected token '$($tokens[$context.Index].Value)'." }
    # Refuse invalid floating-point results such as overflow.
    if ([double]::IsNaN($value) -or [double]::IsInfinity($value)) { throw 'The result is outside the supported numeric range.' }
    # Return the original text alongside a culture-independent numeric result.
    [pscustomobject]@{ Expression = $item; Result = $value }
}

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Accept an explicit decision mode while keeping Fixture as the safe default.
param(
    # Fixture is offline; JevMock uses only the module's local deterministic mock.
    [ValidateSet('Fixture', 'JevMock', 'Live')]
    [string] $Mode = 'Fixture',
    # Optionally load Jev from a specific module manifest.
    [string] $JevModulePath
)
# Stop on errors so an unexpected decision shape fails the validation run.
$ErrorActionPreference = 'Stop'
# Resolve the solution beside this runner.
$solution = Join-Path $PSScriptRoot 'solution.ps1'
# Build arguments without including any key or credential.
$parameters = @{ Mode = $Mode }
if ($JevModulePath) { $parameters.JevModulePath = $JevModulePath }
# Run the selected mode and keep the default path fully deterministic and local.
$results = @(& $solution @parameters)
# Display the structured routing decisions.
$results | Format-Table Id, ChangeKind, Confidence, Urgency, Action, Mode -AutoSize
# Confirm that uncertain input is held for human review.
if (($results | Where-Object Id -eq 'C-104').Action -ne 'Review') { throw 'Uncertain choices must go to Review.' }
# Confirm that customer-facing changes become draft candidates.
if (@($results | Where-Object { $_.Id -in @('C-101', 'C-102') -and $_.Action -ne 'DraftNote' }).Count -gt 0) { throw 'A user-facing change was not kept as a draft note.' }
# Confirm that documentation-only changes are skipped.
if (($results | Where-Object Id -eq 'C-103').Action -ne 'Skip') { throw 'Documentation-only changes must be skipped.' }
# Emit explicit validation checks for the chosen mode.
'Checks: typed Choice and Score answers, confidence review gate, draft-note routing, docs exclusion'
"Mode: $Mode"
if ($Mode -eq 'Fixture') { 'Mode note: no live Jev call' }
'Status: passed'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Turn commit subjects into structured, reviewable release-note candidates.
param(
    # Fixture is network-free by default; JevMock uses the current module's -Mock switch.
    [ValidateSet('Fixture', 'JevMock', 'Live')]
    [string] $Mode = 'Fixture',
    # Permit a caller to point to a locally installed Jev module.
    [string] $JevModulePath
)
# Stop on missing keys, module errors, and unexpected response shapes.
$ErrorActionPreference = 'Stop'

# Keep each synthetic commit small and free of private repository content.
$commits = @(
    [pscustomobject]@{ Id = 'C-101'; Subject = 'Fix the customer invoice export date error' }
    [pscustomobject]@{ Id = 'C-102'; Subject = 'Add a customer repeat-order summary feature' }
    [pscustomobject]@{ Id = 'C-103'; Subject = 'Update the docs for the import option' }
    [pscustomobject]@{ Id = 'C-104'; Subject = 'Reorganize a helper without changing user behavior' }
)

# Set the minimum choice confidence required before PowerShell drafts a note.
$minimumConfidence = 0.75

# Provide deterministic fixture answers that mirror Jev's named answer structure.
$fixtures = @{
    'C-101' = @{ kind = 'fix'; confidence = 0.94; urgency = 1 }
    'C-102' = @{ kind = 'feature'; confidence = 0.91; urgency = 0 }
    'C-103' = @{ kind = 'docs'; confidence = 0.96; urgency = 0 }
    'C-104' = @{ kind = 'internal'; confidence = 0.56; urgency = 0 }
}

# Load Jev and construct typed questions only for its Mock or live integration modes.
if ($Mode -in @('JevMock', 'Live')) {
    # Use an explicit module path when supplied; otherwise load the user's installed module.
    if ($JevModulePath) { Import-Module -Name $JevModulePath -Force -ErrorAction Stop } else { Import-Module -Name Jev -ErrorAction Stop }
    # Classify commit subjects with Jev's current typed Choice question.
    $kindQuestion = New-JevQuestion -Name changeKind -Type Choice -Instructions 'Which category best describes this commit subject?' -Criteria ([ordered]@{
        feature = 'Adds a new capability for users.'
        fix = 'Corrects a problem users can encounter.'
        security = 'Improves security or access safety.'
        docs = 'Changes help or documentation only.'
        internal = 'Changes implementation without user-visible behavior.'
    })
    # Score urgency separately so the two decision fields stay inspectable.
    $urgencyQuestion = New-JevQuestion -Name urgency -Type Score -Instructions 'How urgent is the user-facing impact?' -Criteria @('Routine', 'Soon', 'Urgent')
    # Send both current question objects in one decision request per commit.
    $questions = @($kindQuestion, $urgencyQuestion)
}
# Require the user's own key only for an intentional live request.
if ($Mode -eq 'Live' -and [string]::IsNullOrWhiteSpace($env:TYPESAFE_API_KEY)) { throw 'Live mode requires the user to set TYPESAFE_API_KEY in their own session.' }

# Evaluate every commit, then let ordinary PowerShell apply the visible routing policy.
foreach ($commit in $commits) {
    # Use local fixture answers in the network-free default mode.
    if ($Mode -eq 'Fixture') {
        # Select the fixture for this synthetic commit.
        $fixture = $fixtures[$commit.Id]
        # Build named answers with the fields returned by the current Jev module.
        $decision = [pscustomobject]@{
            model = 'fixture'
            answers = [pscustomobject]@{
                changeKind = [pscustomobject]@{ type = 'choice'; choice = $fixture.kind; confidence = $fixture.confidence }
                urgency = [pscustomobject]@{ type = 'score'; score = $fixture.urgency; confidence = 0.90 }
            }
        }
    }
    else {
        # Send the commit state and typed questions through current Invoke-Jev.
        $invoke = @{ State = $commit; Question = $questions }
        # Use Jev's deterministic local mock without an API request when asked.
        if ($Mode -eq 'JevMock') { $invoke.Mock = $true }
        # Preserve the enriched result so the named answers and confidence remain inspectable.
        $decision = Invoke-Jev @invoke
    }
    # Read the selected category and confidence from Jev's named structured answer.
    $kindAnswer = $decision.answers.changeKind
    $kind = [string] $kindAnswer.choice
    $confidence = [double] $kindAnswer.confidence
    # Route uncertain answers to a person before considering the category.
    $action = if ($confidence -lt $minimumConfidence) { 'Review' } elseif ($kind -in @('feature', 'fix', 'security')) { 'DraftNote' } else { 'Skip' }
    # Return the model result and deterministic PowerShell routing outcome.
    [pscustomobject]@{
        Id = $commit.Id
        Subject = $commit.Subject
        ChangeKind = $kind
        Confidence = $confidence
        Urgency = [double] $decision.answers.urgency.score
        Action = $action
        Mode = $Mode
    }
}

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Stop on errors before printing the deterministic showpiece.
$ErrorActionPreference = 'Stop'
# Resolve the solution beside this runner.
$solution = Join-Path $PSScriptRoot 'solution.ps1'
# Render one fixed-tempo bar without playing audio or writing a file.
& $solution -Bpm 104

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Print a deterministic 16-step rhythm grid using only PowerShell and in-memory arrays.
param(
    # Select a safe tempo label for the printed pattern.
    [ValidateRange(60, 180)]
    [int] $Bpm = 104
)
# Stop on invalid input instead of printing a misleading pattern.
$ErrorActionPreference = 'Stop'

# Define one fixed bar so every run produces the same groove.
$patterns = [ordered]@{
    Kick = @($true, $false, $false, $false, $true, $false, $true, $false, $true, $false, $false, $false, $true, $false, $false, $false)
    Snare = @($false, $false, $false, $false, $true, $false, $false, $false, $false, $false, $false, $false, $true, $false, $false, $false)
    Hat = @($true, $false, $true, $false, $true, $false, $true, $false, $true, $false, $true, $false, $true, $false, $true, $false)
    Clap = @($false, $false, $false, $false, $false, $false, $true, $false, $false, $false, $false, $true, $false, $false, $false, $false)
}
# Print a compact header with four beats divided into sixteenth-note steps.
"POCKET BEAT | $Bpm BPM | 4/4 | deterministic"
# Prepare visible step labels in a single row.
$steps = 1..16 | ForEach-Object { '{0,2}' -f $_ }
"STEP  " + ($steps -join ' ')
# Use distinctive markers so the rhythm reads clearly without color support.
$markers = @{ Kick = '●'; Snare = '◆'; Hat = '▪'; Clap = '✦' }
foreach ($instrument in $patterns.Keys) {
    # Render a marker where the instrument plays and a centered dot where it rests.
    $cells = foreach ($hit in $patterns[$instrument]) { if ($hit) { $markers[$instrument] } else { '·' } }
    # Keep each instrument aligned under the same sixteen step columns.
    '{0,-6} {1}' -f $instrument, ($cells -join '  ')
}
# Print a count-in cue derived from the four quarter-note positions.
'COUNT | 1 & 2 & 3 & 4 &'
'Status: passed'

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Stop on errors so failed serialization checks produce a nonzero process exit.
$ErrorActionPreference = 'Stop'
# Resolve the solution beside this runner.
$solution = Join-Path $PSScriptRoot 'solution.ps1'
# Put special characters and nested values in ordinary PowerShell objects.
$message = 'Customer said: "please check the A&B order."' + [Environment]::NewLine + 'Second line with café and C:\Temp\notes'
$payload = [ordered]@{
    requestId = 'LAB-204'
    message = $message
    details = [ordered]@{
        items = @(
            [ordered]@{ sku = 'A&B-1'; quantity = 2 }
            [ordered]@{ sku = 'C-2'; quantity = 1 }
        )
        flags = [ordered]@{ urgent = $true; reviewed = $false }
    }
}
# Serialize and parse the payload without sending a request.
$result = & $solution -Payload $payload -Depth 12
# Check that quotes, ampersands, line breaks, backslashes, and Unicode survive.
if ($result.Parsed.message -ne $payload.message) { throw 'The message changed during the JSON round-trip.' }
# Check that nested arrays preserve item count and values.
if ($result.Parsed.details.items.Count -ne 2 -or $result.Parsed.details.items[0].sku -ne 'A&B-1') { throw 'Nested item data changed during the JSON round-trip.' }
# Check that a JSON Boolean remains a Boolean.
if ($result.Parsed.details.flags.urgent -ne $true) { throw 'The nested Boolean changed during the JSON round-trip.' }
# Display the exact body that could be supplied as an application/json request body.
"Content-Type: $($result.ContentType)"
"JSON body: $($result.JsonBody)"
"Round-trip: passed ($($result.CharacterCount) characters)"
'Checks: quotes, ampersand, backslash, Unicode, newline, nested arrays, nested booleans'
'Status: passed'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Build a JSON document from data objects instead of hand-escaping JSON text.
param(
    # Accept the structured request object that a caller wants to serialize.
    [Parameter(Mandatory)]
    [object] $Payload,
    # Require a caller-visible depth so nested data is not silently truncated.
    [ValidateRange(2, 100)]
    [int] $Depth = 12
)
# Stop on serialization or parse errors instead of returning partial data.
$ErrorActionPreference = 'Stop'

# Convert a PowerShell object to one compact JSON document and parse it back for verification.
function ConvertTo-VerifiedJsonBody {
    param(
        # The object that represents the request payload.
        [Parameter(Mandatory)]
        [object] $InputObject,
        # The explicit JSON nesting depth selected by the caller.
        [Parameter(Mandatory)]
        [int] $JsonDepth
    )
    # Serialize once with a chosen depth instead of concatenating JSON fragments.
    $json = ConvertTo-Json -InputObject $InputObject -Depth $JsonDepth -Compress
    # Parse as a hashtable so nested keys can be checked by name.
    $roundTrip = ConvertFrom-Json -InputObject $json -AsHashtable -Depth 100
    # Return both the body and parsed data so a caller can inspect the boundary.
    [pscustomobject]@{
        ContentType = 'application/json'
        JsonBody = $json
        Parsed = $roundTrip
        CharacterCount = $json.Length
    }
}

# Return the verified document without sending it to a network or native command.
ConvertTo-VerifiedJsonBody -InputObject $Payload -JsonDepth $Depth

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Stop on errors and require ImportExcel before reporting a workbook result.
$ErrorActionPreference = 'Stop'
Import-Module ImportExcel -ErrorAction Stop
# Use fictional in-memory orders so no customer or network data is needed.
$orders = @(
    [pscustomobject]@{ OrderId = 'O-101'; CustomerId = 'C-1'; Blend = 'Harbor Light'; Quantity = 1; UnitPrice = 14.50; IsRepeat = $false }
    [pscustomobject]@{ OrderId = 'O-102'; CustomerId = 'C-2'; Blend = 'Harbor Light'; Quantity = 2; UnitPrice = 14.50; IsRepeat = $true }
    [pscustomobject]@{ OrderId = 'O-103'; CustomerId = 'C-1'; Blend = 'Night Shift'; Quantity = 1; UnitPrice = 16.00; IsRepeat = $true }
    [pscustomobject]@{ OrderId = 'O-104'; CustomerId = 'C-3'; Blend = 'Night Shift'; Quantity = 1; UnitPrice = 16.00; IsRepeat = $false }
    [pscustomobject]@{ OrderId = 'O-105'; CustomerId = 'C-4'; Blend = 'Citrus Trail'; Quantity = 3; UnitPrice = 13.00; IsRepeat = $false }
    [pscustomobject]@{ OrderId = 'O-106'; CustomerId = 'C-2'; Blend = 'Citrus Trail'; Quantity = 1; UnitPrice = 13.00; IsRepeat = $true }
)
# Write only to an output path inside this lab folder.
$workbook = Join-Path $PSScriptRoot 'coffee-repeat-rates.xlsx'
# Generate the workbook and display its computed summary.
& (Join-Path $PSScriptRoot 'solution.ps1') -Orders $orders -OutputPath $workbook | Format-Table -AutoSize
# Report the path only after the solution returns successfully.
"Workbook: $workbook"
'Status: passed'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Analyze fictional coffee orders and create a small review workbook with ImportExcel.
param(
    # Accept fictional order rows supplied by the safe runner.
    [Parameter(Mandatory)]
    [object[]] $Orders,
    # Write only the requested workbook file.
    [Parameter(Mandatory)]
    [string] $OutputPath
)
# Stop if a row is malformed or the required module is unavailable.
$ErrorActionPreference = 'Stop'
# Load ImportExcel without opening Excel or contacting a remote service.
Import-Module ImportExcel -ErrorAction Stop

# Require the columns needed for calculations and workbook output.
$requiredColumns = @('OrderId', 'CustomerId', 'Blend', 'Quantity', 'UnitPrice', 'IsRepeat')
foreach ($order in $Orders) {
    # Fail clearly when a sample record does not match the expected shape.
    foreach ($column in $requiredColumns) {
        if ($null -eq $order.PSObject.Properties[$column]) { throw "Order '$($order.OrderId)' is missing '$column'." }
    }
}

# Calculate one deterministic summary row for each blend.
$summary = foreach ($group in ($Orders | Group-Object -Property Blend | Sort-Object Name)) {
    # Count unique customers without using external services.
    $customers = @($group.Group.CustomerId | Sort-Object -Unique)
    # Count repeat orders using the supplied Boolean field.
    $repeatOrders = @($group.Group | Where-Object { $_.IsRepeat }).Count
    # Sum revenue by multiplying each quantity by its unit price.
    $revenue = [decimal] 0
    foreach ($order in $group.Group) { $revenue += [decimal] $order.Quantity * [decimal] $order.UnitPrice }
    # Emit a readable row with a rate from zero through one.
    [pscustomobject]@{
        Blend = $group.Name
        Orders = $group.Count
        Customers = $customers.Count
        RepeatOrders = $repeatOrders
        RepeatRate = if ($group.Count -gt 0) { [math]::Round($repeatOrders / $group.Count, 4) } else { 0 }
        Revenue = [math]::Round($revenue, 2)
    }
}

# Define a column chart that compares repeat rates by blend.
$chart = New-ExcelChartDefinition -XRange Blend -YRange RepeatRate -Title 'Repeat order rate by blend' -ChartType ColumnClustered -NoLegend
# Export the source rows as a formatted table on the Orders worksheet.
$Orders | Export-Excel -Path $OutputPath -WorksheetName 'Orders' -TableName CoffeeOrders -AutoSize -FreezeTopRow -BoldTopRow
# Export the summary and chart on a separate worksheet.
$summary | Export-Excel -Path $OutputPath -WorksheetName 'Blend Summary' -TableName BlendSummary -ExcelChartDefinition $chart -AutoSize -FreezeTopRow -BoldTopRow -Append
# Return summary rows so the caller can read results without opening the workbook.
$summary

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Loads the generated deterministic terminal simulation.
. (Join-Path $PSScriptRoot 'solution.ps1')

# Prints five bounded frames with a fixed seed and no delay.
Show-FishSchool -Width 32 -Height 7 -Frames 5 -FishCount 5 -Seed 17

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Prints deterministic text frames of fish moving across a bounded terminal tank.
function Show-FishSchool {
    [CmdletBinding()]
    param(
        # Sets the inner width of each frame.
        [ValidateRange(12, 80)]
        [int] $Width = 32,

        # Sets the inner height of each frame.
        [ValidateRange(4, 20)]
        [int] $Height = 7,

        # Bounds the amount of generated output.
        [ValidateRange(1, 20)]
        [int] $Frames = 5,

        # Sets the number of fish kept in memory.
        [ValidateRange(1, 12)]
        [int] $FishCount = 5,

        # Makes the starting positions repeatable.
        [int] $Seed = 17
    )

    # Creates the deterministic random source used only for initial positions and speeds.
    $random = [System.Random]::new($Seed)

    # Builds a small in-memory record for each fish.
    $fish = @(
        for ($index = 0; $index -lt $FishCount; $index++) {
            [pscustomobject] @{
                X     = $random.Next(0, $Width - 3)
                Y     = $random.Next(0, $Height)
                Speed = $random.Next(1, 3)
            }
        }
    )

    for ($frame = 0; $frame -lt $Frames; $frame++) {
        # Creates a fresh blank character grid for this frame.
        $canvas = @(
            for ($row = 0; $row -lt $Height; $row++) {
                ,([char[]] (' ' * $Width))
            }
        )

        foreach ($item in $fish) {
            # Draws a compact right-facing fish inside the safe horizontal range.
            $canvas[$item.Y][$item.X] = '>'
            $canvas[$item.Y][$item.X + 1] = '<'
            $canvas[$item.Y][$item.X + 2] = '>'

            # Advances and wraps the fish without sleeping or reading input.
            $item.X = ($item.X + $item.Speed) % ($Width - 2)
        }

        # Prints one fully bounded frame using only plain text.
        'Frame {0:d2}' -f ($frame + 1)
        '+' + ('-' * $Width) + '+'
        foreach ($row in $canvas) {
            '|' + (-join $row) + '|'
        }
        '+' + ('-' * $Width) + '+'
    }
}

Captured output, errors, and exit status.

Status: REVIEW-ONLY

PowerShell version: Unavailable (pwsh was not installed and could not be installed in this sandbox)
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: Not available — command was not run
Standard output: Not captured — command was not run
Standard error: Not captured — command was not run

No execution result is claimed for "Make a Tiny School of Fish Swim Through PowerShell".

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Loads the generated function into the current runner scope.
. (Join-Path $PSScriptRoot 'solution.ps1')

# Shows defaults where no parameters were explicitly supplied.
'Call 1: no parameters'
Get-SearchIntent | Format-List

# Shows the difference when switches and a value are explicitly supplied.
'Call 2: switches and limit supplied'
Get-SearchIntent -IncludeArchived -Compact:$false -Limit 5 | Format-List

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Defines a reusable function that separates parameter intent from effective values.
function Get-SearchIntent {
    [CmdletBinding()]
    param(
        # Lets the caller request archived records.
        [switch] $IncludeArchived,

        # Lets the caller request a compact result.
        [switch] $Compact,

        # Limits the number of results while keeping a useful default.
        [ValidateRange(1, 100)]
        [int] $Limit = 20
    )

    # Captures the names the caller explicitly supplied to this invocation.
    $boundNames = @($PSBoundParameters.Keys)

    # Returns an object so intent and values remain easy to inspect or pipe.
    [pscustomobject] [ordered] @{
        IncludeArchivedValue   = $IncludeArchived.IsPresent
        IncludeArchivedPassed  = $boundNames -contains 'IncludeArchived'
        CompactValue           = $Compact.IsPresent
        CompactPassed          = $boundNames -contains 'Compact'
        LimitValue             = $Limit
        LimitPassed            = $boundNames -contains 'Limit'
    }
}

Captured output, errors, and exit status.

Status: REVIEW-ONLY

PowerShell version: Unavailable (pwsh was not installed and could not be installed in this sandbox)
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: Not available — command was not run
Standard output: Not captured — command was not run
Standard error: Not captured — command was not run

No execution result is claimed for "Know If That Switch Was Actually Passed".

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Loads the generated parser into the current runner scope.
. (Join-Path $PSScriptRoot 'solution.ps1')

# Mixes valid and invalid fictional rows so a stale-match bug would be obvious.
$lines = @(
    '[INFO] Queue opened'
    'this row has no tag'
    '[ERROR] Sample item failed validation'
    '[DEBUG] Unsupported tag'
)

# Parses every row and displays a stable object shape.
$lines | ConvertFrom-TaggedMessage | Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Converts tagged text into one predictable object per input line.
function ConvertFrom-TaggedMessage {
    [CmdletBinding()]
    param(
        # Accepts log-like text directly from the pipeline.
        [Parameter(Mandatory, ValueFromPipeline)]
        [string] $Line
    )

    process {
        # Tests and consumes the match in the same branch so stale $Matches data cannot leak.
        if ($Line -match '^\[(?<Level>INFO|WARN|ERROR)\]\s+(?<Message>.+)$') {
            # Copies the current successful capture values into a new object immediately.
            [pscustomobject] [ordered] @{
                Parsed  = $true
                Level   = $Matches.Level
                Message = $Matches.Message
                Source  = $Line
            }
        }
        else {
            # Emits explicit nulls for a failed match instead of reading yesterday's captures.
            [pscustomobject] [ordered] @{
                Parsed  = $false
                Level   = $null
                Message = $null
                Source  = $Line
            }
        }
    }
}

Captured output, errors, and exit status.

Status: REVIEW-ONLY

PowerShell version: Unavailable (pwsh was not installed and could not be installed in this sandbox)
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: Not available — command was not run
Standard output: Not captured — command was not run
Standard error: Not captured — command was not run

No execution result is claimed for "Don’t Let an Old Regex Match Sneak Into the Next Row".

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Loads the generated workbook function.
. (Join-Path $PSScriptRoot 'solution.ps1')

# Creates fictional availability with every person represented for every slot.
$availability = @(
    [pscustomobject]@{ Person = 'Avery'; Slot = 'Tue 10:00'; Available = $true  }
    [pscustomobject]@{ Person = 'Blake'; Slot = 'Tue 10:00'; Available = $true  }
    [pscustomobject]@{ Person = 'Casey'; Slot = 'Tue 10:00'; Available = $false }
    [pscustomobject]@{ Person = 'Avery'; Slot = 'Tue 14:00'; Available = $true  }
    [pscustomobject]@{ Person = 'Blake'; Slot = 'Tue 14:00'; Available = $true  }
    [pscustomobject]@{ Person = 'Casey'; Slot = 'Tue 14:00'; Available = $true  }
    [pscustomobject]@{ Person = 'Avery'; Slot = 'Wed 11:00'; Available = $false }
    [pscustomobject]@{ Person = 'Blake'; Slot = 'Wed 11:00'; Available = $true  }
    [pscustomobject]@{ Person = 'Casey'; Slot = 'Wed 11:00'; Available = $true  }
)

# Writes one local workbook beside the lab files.
$path = Join-Path $PSScriptRoot 'meeting-window.xlsx'
Export-MeetingWindowWorkbook -Availability $availability -Path $path | Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Exports participant availability and a ranked meeting-slot summary.
function Export-MeetingWindowWorkbook {
    [CmdletBinding()]
    param(
        # Accepts records containing Person, Slot, and Available properties.
        [Parameter(Mandatory)]
        [object[]] $Availability,

        # Names the local workbook to create.
        [Parameter(Mandatory)]
        [string] $Path
    )

    # Stops early with a clear message when the required module is unavailable.
    if (-not (Get-Module -ListAvailable -Name ImportExcel)) {
        throw 'ImportExcel is required for this lab.'
    }

    # Counts distinct participants so every slot uses the same denominator.
    $participantCount = @($Availability.Person | Sort-Object -Unique).Count
    if ($participantCount -eq 0) {
        throw 'At least one participant is required.'
    }

    # Builds one summary object for every supplied meeting slot.
    $summary = @(
        $Availability |
            Group-Object Slot |
            ForEach-Object {
                $availableRows = @($_.Group | Where-Object Available)
                [pscustomobject] [ordered] @{
                    Slot             = $_.Name
                    AvailableCount   = $availableRows.Count
                    ParticipantCount = $participantCount
                    AvailablePercent = [math]::Round(($availableRows.Count / $participantCount) * 100, 1)
                    AvailablePeople  = ($availableRows.Person -join ', ')
                }
            } |
            Sort-Object AvailablePercent, Slot -Descending
    )

    # Describes the chart before exporting the summary sheet.
    $chartParameters = @{
        ChartType = 'ColumnClustered'
        XRange    = 'Slot'
        YRange    = 'AvailablePercent'
        Title     = 'Who Can Make Each Time?'
        NoLegend  = $true
    }
    $chart = New-ExcelChartDefinition @chartParameters

    # Writes the inspectable source rows to the first worksheet.
    $rawExport = @{
        Path          = $Path
        WorksheetName = 'Availability'
        TableName     = 'Availability'
        AutoSize      = $true
        FreezeTopRow  = $true
        BoldTopRow    = $true
        ClearSheet    = $true
    }
    $Availability | Export-Excel @rawExport

    # Writes the ranked summary and chart to a separate worksheet.
    $summaryExport = @{
        Path                 = $Path
        WorksheetName        = 'Best Times'
        TableName            = 'MeetingSlots'
        AutoSize             = $true
        FreezeTopRow         = $true
        BoldTopRow           = $true
        ExcelChartDefinition = $chart
    }
    $summary | Export-Excel @summaryExport

    # Returns the summary so callers can inspect the same values without opening Excel.
    $summary
}

Captured output, errors, and exit status.

Status: REVIEW-ONLY

PowerShell version: Unavailable (pwsh was not installed and could not be installed in this sandbox)
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: Not available — command was not run
Standard output: Not captured — command was not run
Standard error: Not captured — command was not run

No execution result is claimed for "Find the Hour Everyone Can Actually Meet".

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Loads the generated Jev-aware router.
. (Join-Path $PSScriptRoot 'solution.ps1')

# Defines fictional requests with no private or credential-bearing data.
$requests = @(
    [pscustomobject]@{ Id = 'REQ-101'; Body = 'Please resend my sample receipt.' }
    [pscustomobject]@{ Id = 'REQ-102'; Body = 'Identity sync and billing disagree across two systems.' }
    [pscustomobject]@{ Id = 'REQ-103'; Body = 'Where can I change my display name?' }
)

# Supplies deterministic answers; the default run makes no API request.
$fixture = @{
    'REQ-101' = $false
    'REQ-102' = $true
    'REQ-103' = $false
}

# Lets PowerShell perform the route after the fixture decision.
Get-SpecialistRoute -Request $requests -Fixture $fixture | Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Routes fictional requests after a narrow Boolean decision.
function Get-SpecialistRoute {
    [CmdletBinding()]
    param(
        # Accepts records with Id and Body properties.
        [Parameter(Mandatory)]
        [object[]] $Request,

        # Enables the optional authenticated Jev path.
        [switch] $Live,

        # Supplies deterministic Boolean decisions for safe local validation.
        [hashtable] $Fixture = @{}
    )

    # Loads the current Jev module only when an authenticated live decision was requested.
    if ($Live -and -not (Get-Command Test-Jev -ErrorAction SilentlyContinue)) {
        Import-Module Jev -ErrorAction Stop
    }

    foreach ($item in $Request) {
        # Rejects incomplete records before either decision path runs.
        if ([string]::IsNullOrWhiteSpace([string] $item.Id) -or
            [string]::IsNullOrWhiteSpace([string] $item.Body)) {
            throw 'Every request needs a non-empty Id and Body.'
        }

        if ($Live) {
            # Uses Jev 0.3.0's pipeline-friendly Boolean command for one narrow question.
            $needsSpecialist = [bool] ($item.Body |
                Test-Jev -Question 'Does this request require a specialist working across systems?' -Threshold 0.75)
            $decisionSource = 'Jev live'
        }
        else {
            # Requires an explicit fixture answer instead of guessing or fabricating an AI response.
            if (-not $Fixture.ContainsKey([string] $item.Id)) {
                throw "Fixture mode needs a decision for request '$($item.Id)'."
            }
            $needsSpecialist = [bool] $Fixture[[string] $item.Id]
            $decisionSource = 'Fixture'
        }

        # Keeps the operational action deterministic and visible in ordinary PowerShell.
        $route = if ($needsSpecialist) { 'Specialist review' } else { 'Self-service queue' }

        # Preserves the input, decision, source, and resulting route for review.
        [pscustomobject] [ordered] @{
            Id              = $item.Id
            Body            = $item.Body
            NeedsSpecialist = $needsSpecialist
            Route           = $route
            DecisionSource  = $decisionSource
        }
    }
}

Captured output, errors, and exit status.

Status: REVIEW-ONLY

PowerShell version: Unavailable (pwsh was not installed and could not be installed in this sandbox)
Command: pwsh -NoLogo -NoProfile -NonInteractive -File ./run.ps1
Exit status: Not available — command was not run
Standard output: Not captured — command was not run
Standard error: Not captured — command was not run

No execution result is claimed for "Let Jev Decide Which Requests Need a Specialist".

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Resolves the fictional sample file beside this runner.
$samplePath = Join-Path $PSScriptRoot 'sample-queue.csv'
# Passes the local sample path to the streaming summarizer.
& (Join-Path $PSScriptRoot 'solution.ps1') -Path $samplePath

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Accepts a CSV file path and summarizes each row without collecting rows in memory.
param(
    # Points to a local CSV file whose header row contains Team.
    [Parameter(Mandatory)]
    [string] $Path
)
# Loads the built-in parser that correctly handles quoted CSV fields.
Add-Type -AssemblyName Microsoft.VisualBasic
# Creates a parser that reads the file as structured comma-separated text.
$parser = [Microsoft.VisualBasic.FileIO.TextFieldParser]::new($Path)
# Configures standard CSV delimiter and quote handling.
$parser.TextFieldType = [Microsoft.VisualBasic.FileIO.FieldType]::Delimited
$parser.SetDelimiters(',')
$parser.HasFieldsEnclosedInQuotes = $true
# Stores only the small running summary, not every source record.
$counts = [ordered]@{}
$total = 0
try {
    # Reads the header row and finds Team without assuming its position.
    $headers = $parser.ReadFields()
    $teamIndex = [Array]::IndexOf($headers, 'Team')
    if ($teamIndex -lt 0) { throw 'The CSV must include a Team column.' }
    # Parses one record at a time and updates only the summary counts.
    while (-not $parser.EndOfData) {
        $fields = $parser.ReadFields()
        $team = $fields[$teamIndex]
        if (-not $counts.Contains($team)) { $counts[$team] = 0 }
        $counts[$team]++
        $total++
    }
}
finally {
    # Closes the local file handle whether parsing succeeds or fails.
    $parser.Dispose()
}
# Prints a compact total and stable alphabetical team summary.
"Total records: $total"
foreach ($team in ($counts.Keys | Sort-Object)) {
    '{0}: {1}' -f $team, $counts[$team]
}

Captured output, errors, and exit status.

REVIEW-ONLY — PowerShell was not available. No stdout or stderr was captured; no run occurred.

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Looks for a local Jev module copy; no installation or live API call is attempted.
$localModulePath = Join-Path $PSScriptRoot 'Jev'
# Uses a local module copy if present, otherwise the installed Jev module.
$parameters = @{}
if (Test-Path (Join-Path $localModulePath 'Jev.psd1')) { $parameters['JevModulePath'] = $localModulePath }
# Runs the fixture with Jev Mock mode selected by the generated solution.
& (Join-Path $PSScriptRoot 'solution.ps1') @parameters

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Requires the current Jev module; Mock mode keeps this example offline.
# Accepts an optional local module path for a source checkout.
param(
    # Supplies the folder containing Jev.psd1 when testing a local copy.
    [string] $JevModulePath
)
# Loads the current Jev command surface without contacting the live service.
if ($JevModulePath) {
    Import-Module (Join-Path $JevModulePath 'Jev.psd1') -Force -ErrorAction Stop
}
else {
    Import-Module Jev -ErrorAction Stop
}
# Provides a fictional incident summary as the model state.
$incident = [pscustomobject]@{
    ticket = 'LAB-204'
    note = 'Several demo clients report a timeout while the sample service still appears healthy.'
}
# Defines a typed Choice and safe, non-executing next-step categories.
$question = New-JevQuestion -Name next_clue -Type Choice -Instructions 'Which broad clue best fits this short incident note?' -Criteria @{
    network = 'The note points to connection or timeout symptoms.'
    service = 'The note points to an unavailable or unhealthy service.'
    unknown = 'The note does not support either clear category.'
}
# Requests a deterministic local mock answer; no API key or network call is needed.
$result = Invoke-Jev -State $incident -Question $question -Mock
# Reads the named Choice answer from Jev structured response.
$answer = $result.answers.next_clue
$category = [string] $answer.choice
$confidence = [double] $answer.confidence
# Keeps low-confidence or unrecognized outcomes with a person for review.
if ($confidence -lt 0.75 -or $category -notin @('network', 'service', 'unknown')) {
    $nextStep = 'Human review'
}
else {
    # Maps a confident category to a harmless suggestion without running commands.
    $nextStep = switch ($category) {
        'network' { 'Check the fictional connection timeline' }
        'service' { 'Review the fictional service health notes' }
        default   { 'Collect one more symptom from the fictional report' }
    }
}
# Prints the choice, its confidence, and the safety-gated suggestion.
[pscustomobject]@{
    Ticket = $incident.ticket
    Category = $category
    Confidence = [math]::Round($confidence, 2)
    NextStep = $nextStep
} | Format-List

Captured output, errors, and exit status.

REVIEW-ONLY — PowerShell and Jev were unavailable. The mock path was not run; no response was fabricated.

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Passes fictional context to the generated formatter.
$solutionPath = Join-Path $PSScriptRoot 'solution.ps1'
# Prints the formatted line returned by the solution.
& $solutionPath -Project 'Northstar' -Branch 'feature/quiet-launch' -HasChanges $true

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Accepts context explicitly so the function does not inspect the shell or profile.
param(
    # Supplies the project label to show.
    [string] $Project = 'Northstar',
    # Supplies the current branch label.
    [string] $Branch = 'feature/quiet-launch',
    # Indicates whether the supplied worktree has edits.
    [bool] $HasChanges = $true
)
# Turns the explicit values into a short, predictable prompt label.
$changeMark = if ($HasChanges) { '*' } else { '' }
# Writes one formatted line without changing the PowerShell prompt function.
'[{0} | {1}{2}]' -f $Project, $Branch, $changeMark

Captured output, errors, and exit status.

REVIEW-ONLY — PowerShell was not available. No stdout or stderr was captured; no run occurred.

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Loads ImportExcel so a missing prerequisite stops clearly.
Import-Module ImportExcel -ErrorAction Stop
# Selects a new timestamped workbook name inside the system temporary directory.
$outputPath = Join-Path ([System.IO.Path]::GetTempPath()) ('coffee-roast-showdown-' + [guid]::NewGuid().ToString('N') + '.xlsx')
# Invokes the generated workbook builder with the unique destination.
& (Join-Path $PSScriptRoot 'solution.ps1') -OutputPath $outputPath

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Requires the ImportExcel module for workbook and chart creation.
# Accepts an output path so the workbook destination stays explicit.
param(
    # Chooses the new workbook path supplied by the runner.
    [Parameter(Mandatory)]
    [string] $OutputPath
)
# Loads the module needed for Excel workbook export.
Import-Module ImportExcel -ErrorAction Stop
# Keeps all tasting notes fictional and in memory.
$tastings = @(
    [pscustomobject]@{ Roast = 'Moonrise'; Taster = 'Ari'; Score = 8.5; Note = 'Chocolate, orange' }
    [pscustomobject]@{ Roast = 'Moonrise'; Taster = 'Bo'; Score = 9.0; Note = 'Smooth finish' }
    [pscustomobject]@{ Roast = 'Daybreak'; Taster = 'Ari'; Score = 7.5; Note = 'Bright, citrus' }
    [pscustomobject]@{ Roast = 'Daybreak'; Taster = 'Bo'; Score = 8.0; Note = 'Light body' }
    [pscustomobject]@{ Roast = 'Night Ferry'; Taster = 'Ari'; Score = 9.5; Note = 'Deep cocoa' }
    [pscustomobject]@{ Roast = 'Night Ferry'; Taster = 'Bo'; Score = 9.0; Note = 'Warm spice' }
)
# Calculates one average score per roast for the chart and summary sheet.
$summary = $tastings | Group-Object Roast | ForEach-Object {
    [pscustomobject]@{
        Roast = $_.Name
        AverageScore = [math]::Round((($_.Group | Measure-Object Score -Average).Average), 2)
        TastingCount = $_.Count
    }
} | Sort-Object @{ Expression = 'AverageScore'; Descending = $true }, @{ Expression = 'Roast'; Descending = $false }
# Creates a chart definition explicitly so workbook export receives a valid chart object.
$chart = New-ExcelChartDefinition -ChartType BarClustered -XRange Roast -YRange AverageScore -Title 'Average Roast Score' -NoLegend
# Creates a summary sheet with the chart and score color scale.
$summary | Export-Excel -Path $OutputPath -WorksheetName 'Roast Summary' -AutoSize -BoldTopRow -FreezeTopRow -TableName 'RoastSummary' -ConditionalFormat @{ AverageScore = 'ThreeColorScale' } -ExcelChartDefinition $chart
# Adds the fictional tasting records as a separate inspectable worksheet.
$tastings | Export-Excel -Path $OutputPath -WorksheetName 'Tasting Notes' -AutoSize -BoldTopRow -FreezeTopRow -TableName 'TastingNotes' -Append
# Reports the requested path without opening or changing other files.
"Workbook created: $OutputPath"

Captured output, errors, and exit status.

REVIEW-ONLY — PowerShell and ImportExcel were unavailable. No workbook was created and no stdout or stderr was captured.

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Uses a small deterministic frame size so output stays compact.
$width = 20
$height = 7
$frames = 4
# Invokes the generated simulator with bounded dimensions.
& (Join-Path $PSScriptRoot 'solution.ps1') -Width $width -Height $height -Frames $frames

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Creates a bounded text-only bounce simulation using explicit dimensions and frame count.
param(
    # Sets the width of each rendered frame.
    [ValidateRange(10, 50)]
    [int] $Width = 24,
    # Sets the height of each rendered frame.
    [ValidateRange(5, 20)]
    [int] $Height = 9,
    # Sets a small upper bound so output remains easy to inspect.
    [ValidateRange(1, 8)]
    [int] $Frames = 4
)
# Starts the logo near the upper-left and gives it a repeatable direction.
$x = 1
$y = 1
$dx = 1
$dy = 1
$logo = 'DVD'
# Renders each state into a fresh fixed-width character grid.
for ($frame = 1; $frame -le $Frames; $frame++) {
    $canvas = for ($row = 0; $row -lt $Height; $row++) { ' ' * $Width }
    $canvas = [System.Collections.Generic.List[string]]::new([string[]] $canvas)
    # Places the short logo into the current row without changing the grid size.
    $line = $canvas[$y].ToCharArray()
    for ($character = 0; $character -lt $logo.Length; $character++) { $line[$x + $character] = $logo[$character] }
    $canvas[$y] = -join $line
    # Prints a frame label followed by the plain-text picture.
    "Frame $frame"
    $canvas
    # Computes the next position and reverses direction at each edge.
    $nextX = $x + $dx
    $nextY = $y + $dy
    if ($nextX -lt 0 -or $nextX + $logo.Length -ge $Width) { $dx *= -1 }
    if ($nextY -lt 0 -or $nextY -ge $Height) { $dy *= -1 }
    $x += $dx
    $y += $dy
}

Captured output, errors, and exit status.

REVIEW-ONLY — PowerShell was not available. No frames or stdout/stderr were captured; no run occurred.