►
A
A
A
That's
a
helper,
so
we'll
put
it
up
there.
No
spell
set.
No
spell
turns
off.
The
spell
hints
set
spell:
this
is
a
bim.
So
if
you
do
vam,
I
search
escape
and
then
shift
and
then
the
semicolon
so
escape
colon
escape
colon
gets
you
to
this,
and
then
you
can
say
set
spell
it'll
turn
on
spell
hunting
and
if
you
do
escape
quan
again,
you
do
set
no
spell
it'll
turn
off
spell
spell
spell
checking
okay,
so
file
path.
B
A
A
C
D
A
B
A
This
is
like
so
easy:
it's,
okay,
okay,
it's
just
like
I'm
like
I'm
fit.
I
feel
like
I'm
failing
to
see
something
that
should
be
really
obvious
to
me.
Okay,
all
we
want
to
do
is
take
this.
Okay,
take
this
on
at
an
at
okay.
I
want
to
give
you
a
function.
I
want
to
give
you
a
function
and
I'm
going
to
give
you
a
function.
Okay,
okay,
return
that
return
that
oh.
A
B
A
E
A
D
A
E
A
E
D
C
A
A
A
B
A
C
A
A
A
A
A
A
A
B
E
A
We're
defining
it
okay,
so
the
output
method
is
going
to
come
later
so
right
now,
what
we're
doing
is
we're
defining
a
method
call.
An
output
method
is
just
a
overlay
passed
to
the
op
sc.
So,
basically,
before
you
do
an
op
sc,
if
you
were
doing
a
data
flow
on
the
fly
or
an
overlay
on
the
fly,
you
would
do
down
here
at
like
117,
you
could
do
you
could
do
this
op
sc.
A
D
A
A
A
C
D
A
B
C
A
It
doesn't
matter
it
doesn't
matter,
because
the
system
context
is
really
just
a
system
context
config.
There
is
no
like
plug-in
type.
It's
just
a
system
context
config,
because
the
system
context
this
is
the
generic
construct,
which
is
this
sort
of
like
maybe
the
system
context
is
the
open
architecture.
A
A
A
A
A
B
C
D
C
A
A
A
B
D
A
C
A
A
A
A
A
A
A
A
A
A
If
you
need
an
entity,
if
you
need
to
call
this
sayhello
function
and
you
need
an
entity
go
ahead
and
run
this
git
entity
routine,
all
right
so
and
by
passing
it
in
here,
we
set
it
as
the
default,
so
we'll
have
the
default
output
for
a
flow.
So,
if
you
were
to
say
so
say
we
have
a
data
flow
is
class
right
and
we
do
a
async
4
error
like
system
context
right
as
says
ctx.
A
A
A
A
Source
of
entity
via
installed
overlays.
So
when
we
run
the
say
hello
operation,
if
alice
determines
so
if
alice,
if
alice
suggests.
So
if
a
strategic
plan
suggests
that
the
say
hello
operation
might
be,
something
is
a
system
context
which
it
submits
as
a
thought
which
should
be
executed
within
first
first,
it
figured
first
she's
she
hears
so
she
hears
us
and
she
says.
A
Response
so
two
different
things
happen
right,
so
one
strategic
plan
says
response
requested.
You
know,
like
somebody's
gonna,
want
to
hear
you
respond
to
them
within
a
specific
amount
of
time.
You
should
say
something
right,
something
that
would
be
appropriate
to
say
when
someone
says
hi
alice
right,
depending
on
the
the
context
right.
So
then
she's
going
to
have
other
strategic
plans
that
go
out,
irrespective
of
the
fact
that
it
says
some.
You
should
say
something
right
and
say
it
analyzes
the
parent
system,
context
and
says
alice.
A
B
A
A
Trigger
for
response,
if
needed
so
we're
using
a
very
simple
case
right
now
of
talking
to
alice,
but
this
is
also
going
to
translate
to
like
our
pr
validation
when
we're
doing
those
when
we're
like
doing
that.
A
b
feature
testing
where
we're
cherry
picking
across
branches
and
we
need
to
decide
and
we
need
to
decide
what
is
pertinent
information
for
the
maintainers
that
are
considering
merging
this
branch.
A
In
terms
of
how
does
this
data
that
we're
seeing
coming
in
and
have
seen
coming
in
up
until
the
time
where
you're
deciding
to
hit
merge
or
not
right,
because
we're
basically
working?
If,
if
we're
thinking
that
we're
alice
right
now
we're
working
with
this
timeline?
Where
you're
doing
the
review
and
she's
trying
to
generate
as
much
information
for
you
as
she
can
to
help
you
within
the
context
of
that
code,
review
right
and
she
can't
do
everything
right.
A
But
while
you're,
you
know
from
the
moment
the
pr
gets
submitted,
she
can
start
collecting
as
much
information
as
possible
and
doing
as
much.
You
know
little
edits
and
stuff
to
make
it.
You
know
to
just
bring
it
up
to
juno.
Hey
discover
any
standards
that
need
to
be
applied
based
on
the
organizational
context
right
and
then
apply
them.
You
know
maybe
rework
the
pr
in
an
automated
fashion,
with
the
contributor
until
the
maintainer
comes
in
and
then
she
can
to
tell
the
maintainer.
A
You
know
here's
the
things
that
you
need
to
know,
but
she
doesn't
know
when
the
maintainer's
going
to
get
there
right,
so
she's
going
to
constantly
re-prioritize
based
on
what
information,
she's
gathering
and
what
scientific
processes
she's
going
out,
what
debugging
she's
taking
to
try
to
figure
out.
Okay,
how
do
I
generate?
How
do
I
like
do
as
much
code
review
on
this
thing,
as
I
possibly
can
before
the
maintainer
get
gets
here
right
for
this
new
contributors?
A
Pr-
and
you
know
this
is
obviously
so
hello
world-
is
the
very
first
step
in
that
right.
So
we're
saying
you
know
what
what
do
we
suggest
that
she
does
when
someone
says
when,
when
we
need
her
to
say
hello
right,
but
this
is
the
same
once
again,
it's
all
the
same
process
right.
So
if
you
say
instead
of
say
hello,
it's
respond
to
pr
right.
Then,
what's
your
suggested
flow?
A
Well,
my
suggested
flow
with
respond
to
pr
my
default
flow
that
we're
going
to,
maybe
you
know,
have
as
part
of
the
default
set
of
dfml
flows
that
get
overlaid
right.
So
we're
gonna
write
an
overlay,
we're
going
to
install
the
overlay
and
then,
when
the
when
we
run
so
when
we
run
alice
she
will
she
will
pick
up
any
installed
overlays.
She
will
examine
her
context
that
she's
running
within
and
she
will,
you
know,
execute
within
that
context
as
appropriate
right.
A
So
each
different
plugin
is
going
to
have
different
sort
of
remember
it's
this
adaptive,
it's
this
adaptive,
ci
right,
and
so
it's
this
adaptive
context,
aware
ci,
and
so
these
overlays
are
gonna.
Allow
us
to
have
project
specific
settings
as
but
also
facilitate
you
know,
taking
these
settings
across
projects
and
monitoring
them
in
in
a
uniform
way,
so
that
we
can
have
you
know
as
much
information
about
our
development
process
as
possible
right
to
see
how
our
different
strategies
are
are
playing
out
when
they're
applied
via
these
overlays
right.
A
A
By
which
you
can,
by
which
we
can
sort
of
represent
upstream
and
differences
from
upstream
and
then
track
divergences
and
evolutions,
as
well
as
performance,
enhancements
or
or
potential
optima
like
areas
for
optimization,
so
we're
really
it's
once
again.
It's
all
the
same
thing
right.
So
when
you
have
this,
then
you
can
go
optimize
across
and
you
can
do
those
state
of
the
art.
You
know
those
a
b
feature
tested
branches:
okay,
oh
yeah.
I
know
I
promise
time
traveling.
A
B
C
A
A
B
B
C
B
A
So
self
phrase
heard
and
our
entity's
name
all
right,
so
phrase
starts
with
phrase
dot
lower
starts
with
our
entitiesname.lower,
then
we're
gonna
assume
that
they're
talking
to
us
right.
So
this
is
pretty.
This
is
pretty.
This
is
very
basic
logic.
Obviously
it's
gonna
fail
on
a
lot
of
cases,
but
it's
for
the
point
of
illustration
right.
So.
C
C
C
A
A
If
we
say
of
weight,
strategic
principles,
it'll
go
run
the
strategic
principles,
so
if
we
say
alice
so
if
alice
is
running
and
she's
running
in
a
default
flow
which
has
her
listening
right,
so
she's
running
in
a
default
flow
where
she's
listening
to
phrases
right.
So,
let's
see
phrase
heard
so,
let's
see
right
so.
A
A
C
C
A
A
A
This
listen
for
phrases
says
this
is
the
example
phrase
source
right,
so
we
might
have
this
be
like
pull
request
right,
so
this
is
for
for
for
the
ci
cd
case.
This
is
artifacts
incoming.
This
is
pull
request.
This
is
whatever
right.
This
is
your
arbitrary
event
source,
okay.
So,
but
by
default,
we're
saying
you
know,
listen
for
so
example,
phrase
source.
Okay.
So
if
you
run
listen
for
phrases,
okay,.
B
C
C
A
B
D
A
D
D
A
D
C
B
A
And
why
is
this
we're
keeping
dependency
information
with
the
function
right?
So
you
you
claim
you
take
a
key.
This
is
kind
of
like
the
property
testing
stuff
that
that's
in
the
thread.
You
claim
you
take
a
key.
Well
prove
it
give
me
a
default
one
that
works.
You
know,
give
me
one
functional
freaking
example.
You
know:
okay,.
A
I'm
trying
to
figure
this
out.
I
think
I'm
just
what
I'm
doing
right
now
is
I'm
just
chaining
things
up
until
we
figure
out
where
the
bottom
of
this
rabbit
hole
is
so
we're
just
doing
this
full
example.
Basically,
so
the
whole
thing
has
to
be
configurable
right
because
we
have
to
have
configurability
everywhere
so
that
it's
the
to
prove
it
we're
doing,
prove
it
right
now,
poc,
let's
see
okay.
A
A
A
A
A
C
A
D
A
B
A
A
C
C
A
A
A
A
A
A
A
A
I
think
we're
going
to
eventually
end
up
with
doc
strings
that
actually
that
when
we'll
have
some
format
for
the
doc
strings,
which
will
allow
us
to
write
in
the
docstring,
basically
the
things
that
will
are
right
now
being
passed
to
op
and
that
way
we
can
have
our
documentation
as
code
or
our
yeah.
We
can
have
our
testable
documentation
for
each
case
and
we'll
just
split
out
the
cases
into
these.
A
So,
like
example,
is
here
and
then
maybe
it
would
say
like
hey
here's,
how
you
use
this
with
blank
right
and
then
here's
how
you
use
it
with
variables
from
the
environment,
okay,
blank
here's
another
data
flow
right,
so
the
other,
the
other
possible
paths
to
get
here
in
terms
of
dependent
dependency,
satisfaction.
So.